comprehension 0.2.0

Iterator comprehension in Rust
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

use comprehension::*;

#[test]
fn test_iter() {
    assert_eq!(vect![1; ], vec![1]);
    assert_eq!(vect![1; true], vec![1]);
    assert!(vect![1; false].is_empty());

    assert_eq!(
        vect![x * x; x <- 0..10],
        vec![0, 1, 4, 9, 16, 25, 36, 49, 64, 81],
    );

    assert_eq!(
        vect![x * y; x <- 1..=3, y <- 1..=3],
        vec![1, 2, 3, 2, 4, 6, 3, 6, 9],
    );

    assert_eq!(
        vect![x * y; x <- vec![1, 2, 3], y <- vec![1, 2, 3]],
        vec![1, 2, 3, 2, 4, 6, 3, 6, 9],
    );

    let mat = vec![vec![1, 2, 3]; 3];
    assert_eq!(
        vect![cell; row <- mat, cell <- row],
        vec![1, 2, 3, 1, 2, 3, 1, 2, 3],
    );

    assert_eq!(vect![x * x; x <- 0..10, x % 2 == 0], vec![0, 4, 16, 36, 64]);

    assert_eq!(
        vect![(*i, j); i <- &[1, 2], j <- 1..=3],
        vec![(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3)],
    );

    assert_eq!(
        iter![(*i, j); i <- &[1, 2], j <- 1..]
            .take(5)
            .collect::<Vec<_>>(),
        vec![(1, 1), (1, 2), (1, 3), (1, 4), (1, 5),],
    );

    assert_eq!(
        iter![vect![(*i, j); i <- &[1, 2] ]; j <- 1..]
            .take(5)
            .collect::<Vec<_>>(),
        vec![
            vec![(1, 1), (2, 1)],
            vec![(1, 2), (2, 2)],
            vec![(1, 3), (2, 3)],
            vec![(1, 4), (2, 4)],
            vec![(1, 5), (2, 5)],
        ],
    );

    fn gcd(a: i32, b: i32) -> i32 {
        if b == 0 {
            a
        } else {
            gcd(b, a % b)
        }
    }

    assert_eq!(
        iter![(i, j); i <- 1.., j <- 1..i, gcd(i, j) == 1]
            .take(10)
            .collect::<Vec<_>>(),
        vec![
            (2, 1),
            (3, 1),
            (3, 2),
            (4, 1),
            (4, 3),
            (5, 1),
            (5, 2),
            (5, 3),
            (5, 4),
            (6, 1),
        ],
    );

    assert_eq!(
        iter![(i, j); i <- 1.., let k = i * i, j <- 1..=k ]
            .take(10)
            .collect::<Vec<_>>(),
        vec![
            (1, 1),
            (2, 1),
            (2, 2),
            (2, 3),
            (2, 4),
            (3, 1),
            (3, 2),
            (3, 3),
            (3, 4),
            (3, 5)
        ],
    );

    assert_eq!(
        iter![c.to_ascii_uppercase(); c <- "Hello".chars()].collect::<String>(),
        "HELLO"
    );

    assert_eq!(55, sum![i; i <- 1..=10]);
    assert_eq!(3628800, product![i; i <- 1..=10]);

    let t = vect![(x, y); x <- 1..=3, y <- 1..=3];
    assert_eq!(vect![x * y; (x, y) <- t], vec![1, 2, 3, 2, 4, 6, 3, 6, 9]);
}