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

use core::fmt;
use std::option;


#[derive(PartialEq, Debug)]
pub struct Shoe {
    pub size: u32,
    pub style: String,
}

pub struct Counter {
    count: u32
}

impl Counter {
    pub fn new() -> Counter {
        Counter { count: 0}
    }
}

impl Iterator for Counter {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        self.count += 1;

        if self.count < 6 {
            Some(self.count)
        } else {
            None
        }
    }
}

pub fn shoe_in_my_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> {
    println!("size: {}", shoe_size);
    shoes.into_iter().filter(|s|s.size == shoe_size).collect()
}

#[test]
fn filters_by_size() {
    let shoes = vec![
        Shoe {size: 40, style: String::from("特步")},
        Shoe {size: 41, style: String::from("耐克")},
        Shoe {size: 40, style: String::from("安踏")},
    ];

    assert_eq!(shoe_in_my_size(shoes, 40), vec![
        Shoe {size:40, style:String::from("特步")},
        Shoe {size:40, style: String::from("安踏")},
    ])
}
#[test]
fn test_counter() {
    let mut c = Counter::new();
    assert_eq!(c.next(), Some(1));
    assert_eq!(c.next(), Some(2));
    assert_eq!(c.next(), Some(3));
    assert_eq!(c.next(), Some(4));
    assert_eq!(c.next(), Some(5));
    assert_eq!(c.next(), None);
}
#[test]
fn using_other_iterator_trait_methods() {
    let sum: u32 = Counter::new().zip(Counter::new().skip(1))
                            .map(|(a,b)| a * b)
                            .filter(|x| x % 3 == 0)
                            .sum();
    assert_eq!(18, sum);
}