Concurrency: threads, goroutines & channels

sub main(): Int {
    $results: Chan[Int] = channel()

    # One task does all the sends, then closes the channel.
    # Captured @nums is immutable, so no task can race on it.
    @nums = [1, 2, 3, 4, 5]
    hatch {
        for $n in @nums {
            $results.send($n * $n)   # squares cross the channel
        }
        $results.close()             # signal "no more values"
    }

    # `for` over a channel drains it until closed (§17.4).
    mut $total = 0
    for $sq in $results {
        $total = $total + $sq
    }
    print("sum of squares: $total")
    0
}

package main

import (
	"fmt"
	"sync"
)

func main() {
	results := make(chan int)
	var wg sync.WaitGroup

	// One goroutine per number; each sends its square.
	for n := 1; n <= 5; n++ {
		wg.Add(1)
		go func(n int) {
			defer wg.Done()
			results <- n * n
		}(n)
	}

	// Close the channel once every worker is done so range ends.
	go func() { wg.Wait(); close(results) }()

	total := 0
	for v := range results {
		total += v
	}
	fmt.Printf("sum of squares: %d\n", total)
}

(* OCaml 5: effects-based domains + a Mutex-guarded Queue as the channel. *)
let () =
  let results = Queue.create () in
  let mtx = Mutex.create () in
  let send v =
    Mutex.lock mtx; Queue.push v results; Mutex.unlock mtx in
  (* Spawn one domain per number; each sends its square. *)
  let workers =
    List.map (fun n -> Domain.spawn (fun () -> send (n * n)))
      [1; 2; 3; 4; 5]
  in
  List.iter Domain.join workers;
  let total = Queue.fold ( + ) 0 results in
  Printf.printf "sum of squares: %d\n" total

use strict;
use warnings;
use threads;
use Thread::Queue;

my $results = Thread::Queue->new;

# Spawn one thread per number; each enqueues its square.
my @workers = map {
    my $n = $_;
    threads->create(sub { $results->enqueue($n * $n) });
} 1 .. 5;

$_->join for @workers;   # wait for every worker

my $total = 0;
$total += $results->dequeue for 1 .. 5;
print "sum of squares: $total\n";

my @nums = 1, 2, 3, 4, 5;

# `start` returns a Promise; the block runs on the thread pool.
my @promises = @nums.map(-> $n { start { $n * $n } });

# await blocks until all Promises are kept, returning their values.
my $total = await(@promises).sum;
say "sum of squares: $total";

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    // One thread per number; each moves a sender clone and sends its square.
    for n in 1..=5 {
        let tx = tx.clone();
        thread::spawn(move || {
            tx.send(n * n).unwrap();
        });
    }
    drop(tx); // drop the original so rx ends once all clones are gone

    let total: i32 = rx.iter().sum();
    println!("sum of squares: {total}");
}

import threading
import queue

results = queue.Queue()

def worker(n):
    results.put(n * n)  # send the square through the queue

# Spawn one thread per number, then join them all.
threads = [threading.Thread(target=worker, args=(n,)) for n in range(1, 6)]
for t in threads:
    t.start()
for t in threads:
    t.join()

total = sum(results.get() for _ in range(5))
print(f"sum of squares: {total}")