goish 0.20.7

Goish Rust — write Rust using Go idioms. Ports Go's standard library and syntax so Go programmers can write Rust code that reads and feels like Go.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

// worker: a small worker-pool demo that exercises most of goish.
//
//   $ cargo run --example worker
//
// Go-idiomatic features in use:
//   - go!{...}      goroutines (spawn worker threads)
//   - chan!(...)    channels for jobs and results
//   - defer!{...}   scope-end cleanup
//   - time::Sleep   simulated work
//   - time::Since   measure elapsed duration
//   - range!(...)   Go-style for k, v := range m
//   - strings::    text helpers
//   - os::Args    command-line arguments
//   - fmt::Println, Printf, Errorf, Stringer

use goish::prelude::*;

// A job: an integer to square.
#[derive(Clone, Default)]
struct Job { id: int, n: int }

fmt::stringer! {
    impl Job {
        fn String(&self) -> string {
            fmt::Sprintf!("Job#%d(n=%d)", self.id, self.n)
        }
    }
}

// A result the worker emits back.
#[derive(Clone, Default)]
#[allow(dead_code)]
struct Result { job_id: int, square: int, worker: int }

fn worker(id: int, jobs: Chan<Job>, results: Chan<Result>) {
    defer!{ fmt::Printf!("worker %d: shutting down\n", id); }
    loop {
        let (job, _) = jobs.Recv();
        if job.id < 0 { return; }  // sentinel: id<0 → stop

        // Simulated work.
        time::Sleep(time::Millisecond * 20i64);
        let r = Result { job_id: job.id, square: job.n * job.n, worker: id };
        results.Send(r);
    }
}

fn main() {
    // Optional CLI: `cargo run --example worker 8` → 8 jobs.
    let args = os::Args();
    let n_jobs: int = if args.len() >= 2 {
        let (n, err) = strconv::Atoi(&args[1]);
        if err != nil {
            fmt::Println!("bad arg:", err);
            os::Exit(1);
        }
        n
    } else { 6 };

    fmt::Printf!("running %d jobs across 3 workers...\n", n_jobs);
    let start = time::Now();

    let jobs: Chan<Job> = chan!(Job, 16);
    let results: Chan<Result> = chan!(Result, 16);

    // Fan out: 3 workers.
    let mut handles: slice<Goroutine> = make!([]Goroutine, 0, 3);
    for w in 1i64..=3 {
        let j = jobs.clone();
        let r = results.clone();
        handles.push(go!{ worker(w, j, r); });
    }

    // Feed jobs, then one sentinel per worker to signal "stop".
    // (close!(&jobs) also works — Go programs use either pattern; sentinels
    // compose best when producers outnumber the consumers.)
    for i in 1i64..=n_jobs {
        jobs.Send(Job { id: i, n: i + 10 });
    }
    for _ in 0..3 {
        jobs.Send(Job { id: -1, n: 0 });  // sentinel
    }

    // Collect results.
    let mut by_worker: map<int, slice<int>> = make!(map[int]slice<int>);
    for _ in 0..n_jobs {
        let (r, _) = results.Recv();
        let entry = by_worker.entry(r.worker).or_insert_with(|| slice::<int>::new());
        entry.push(r.square);
    }

    // Wait for workers to finish (they'll exit after their sentinel job).
    for g in handles { let _ = g.Wait(); }

    // Summary.
    fmt::Println!();
    fmt::Println!("results by worker:");
    let mut worker_ids: slice<&int> = by_worker.keys().collect();
    worker_ids.sort();
    for (_, wid) in range!(worker_ids) {
        let squares = &by_worker[*wid];
        let as_strs: slice<string> = squares.iter().map(|n| strconv::Itoa(*n)).collect();
        fmt::Printf!("  worker %d: %d squares [%s]\n",
            **wid, len!(squares), strings::Join(&as_strs, ", "));
    }

    let elapsed = time::Since(start);
    fmt::Printf!("\nfinished in %s\n", elapsed);
}