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

// Auto-generated by goishc. Review before shipping.
#![allow(non_snake_case)]
#![allow(non_camel_case_types)]
#![allow(unused_imports)]
#![allow(unused_variables)]
#![allow(unused_mut)]
#![allow(dead_code)]

use goish::prelude::*;

// from Go package main

// import "errors" → errors (via prelude)
// import "fmt" → fmt (via prelude)
// import "strconv" → strconv (via prelude)

Struct!{ type PathTest struct {
    path, result string
} }

var!(ErrNotFound = errors::New("not found"));
Const! {
    Sunday = iota;
    Monday;
    Tuesday;
}
pub fn divide(a: int64, b: int64) -> (int64, error) {
    if b == 0 {
        return (0, errors::New("divide by zero"));
    }
    return (a / b, nil);
}

pub fn main() {
    let mut cases = slice!([]PathTest{PathTest!("a", "A"), PathTest!("b", "B")});
    for (i, c) in range!(cases) {
        Printf!("case %d: %s -> %s\n", i, c.path, c.result);
    }
    let mut nums = slice!([]int{1, 2, 3, 4, 5});
    let mut total = 0;
    for (_, n) in range!(nums) {
        total += n;
    }
    Println!("total:", total);
    let mut m = map!([string]int{"a" => 1, "b" => 2});
    for (k, v) in range!(m) {
        Println!(k, v);
    }
    let (q, err) = divide(10, 2);
    if err != nil {
        Println!("error:", err);
    } else {
        Println!("q =", q);
    }
    let (s, err) = strconv::Atoi("42");
    if err == nil {
        Println!(s);
    }
    for i in 0..3 {
        Println!(i);
    }
}