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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

// range: trait backing the `range!` macro.
//
// Different Go types give different shapes to `range`:
//   - slices/arrays → (index, &value)
//   - maps          → (&key, &value)
//   - strings       → (byte-index, rune/char)
//   - channels      → value (we only iterate values out of a Chan)
//
// `RangeIter` dispatches each of these to the right std iterator.

pub trait RangeIter {
    type Item;
    type Iter: Iterator<Item = Self::Item>;
    fn range(self) -> Self::Iter;
}

// ── slices & Vecs ──────────────────────────────────────────────────────

impl<'a, T> RangeIter for &'a [T] {
    type Item = (usize, &'a T);
    type Iter = std::iter::Enumerate<std::slice::Iter<'a, T>>;
    fn range(self) -> Self::Iter {
        self.iter().enumerate()
    }
}

// Fixed-size arrays — Go's `[N]T` or inline `[...]T{...}`.
impl<'a, T, const N: usize> RangeIter for &'a [T; N] {
    type Item = (usize, &'a T);
    type Iter = std::iter::Enumerate<std::slice::Iter<'a, T>>;
    fn range(self) -> Self::Iter {
        self.iter().enumerate()
    }
}

impl<'a, T> RangeIter for &'a Vec<T> {
    type Item = (usize, &'a T);
    type Iter = std::iter::Enumerate<std::slice::Iter<'a, T>>;
    fn range(self) -> Self::Iter {
        self.iter().enumerate()
    }
}

// Goish slice<T> — same shape as Vec<T>; Deref handles most call sites,
// but trait impls don't walk Deref, so we impl RangeIter explicitly.
impl<'a, T> RangeIter for &'a crate::_slice::slice<T> {
    type Item = (usize, &'a T);
    type Iter = std::iter::Enumerate<std::slice::Iter<'a, T>>;
    fn range(self) -> Self::Iter {
        self.as_slice().iter().enumerate()
    }
}

// ── maps ───────────────────────────────────────────────────────────────

impl<'a, K, V> RangeIter for &'a std::collections::HashMap<K, V> {
    type Item = (&'a K, &'a V);
    type Iter = std::collections::hash_map::Iter<'a, K, V>;
    fn range(self) -> Self::Iter {
        self.iter()
    }
}

// ── strings ────────────────────────────────────────────────────────────

impl<'a> RangeIter for &'a str {
    type Item = (usize, char);
    type Iter = std::iter::Enumerate<std::str::Chars<'a>>;
    fn range(self) -> Self::Iter {
        self.chars().enumerate()
    }
}

impl<'a> RangeIter for &'a String {
    type Item = (usize, char);
    type Iter = std::iter::Enumerate<std::str::Chars<'a>>;
    fn range(self) -> Self::Iter {
        self.chars().enumerate()
    }
}

// Double-ref for string literals: range!("abc") expands to range(&"abc") = &&str.
impl<'a> RangeIter for &'a &str {
    type Item = (usize, char);
    type Iter = std::iter::Enumerate<std::str::Chars<'a>>;
    fn range(self) -> Self::Iter {
        (*self).chars().enumerate()
    }
}

#[cfg(test)]
mod tests {
    use crate::types::*;

    #[test]
    fn range_slice_gives_index_and_ref() {
        let v: slice<int> = crate::slice!([]int{10, 20, 30});
        let mut collected: Vec<(usize, int)> = Vec::new();
        for (i, val) in crate::range!(v) {
            collected.push((i, *val));
        }
        assert_eq!(collected, vec![(0, 10), (1, 20), (2, 30)]);
    }

    #[test]
    fn range_map_gives_key_and_value_refs() {
        let m: map<string, int> = crate::map!([string]int{"a" => 1, "b" => 2});
        let mut total = 0i64;
        for (_k, v) in crate::range!(m) {
            total += *v;
        }
        assert_eq!(total, 3);
    }

    #[test]
    fn range_str_gives_index_and_rune() {
        let mut chars: Vec<(usize, char)> = Vec::new();
        for (i, r) in crate::range!("abc") {
            chars.push((i, r));
        }
        assert_eq!(chars, vec![(0, 'a'), (1, 'b'), (2, 'c')]);
    }

    #[test]
    fn range_value_only_form() {
        let v: slice<int> = crate::slice!([]int{1, 2, 3});
        let mut sum = 0i64;
        for x in v.into_iter() { sum += x; }
        assert_eq!(sum, 6);
    }
}