hs-rust-learn 0.1.0

#[derive(Clone)]
struct Counter {
    count: i32,
    total: i32,
}

impl Counter {
    fn new(total: i32) -> Counter {
        Counter {
            total,
            count: 0,
        }
    }
}

impl Iterator for Counter {
    type Item = i32;
    fn next(&mut self) -> Option<Self::Item> {
        if self.count < self.total {
            self.count += 1;
            Some(self.count)
        } else {
            None
        }
    }
}

#[test]
fn call_next() {
    let mut c = Counter::new(5);
    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);

    let x = Counter::new(5).zip(Counter::new(5).skip(1)).map(|(a, b)| a * b).filter(|x| x % 3 == 0);
    let y: i32 = x.clone().sum();
    println!("{}", y);
    for a in x {
        println!("{}", a);
    }
}


fn main() {
    let v1 = vec![2,4,6];
    let mut v1_iter = v1.iter();
    // for i in v1_iter {
    //     println!("{}", i);
    // }
    println!("{}", v1_iter.next().unwrap());
    println!("{}", v1_iter.next().unwrap());
    println!("{}", v1_iter.next().unwrap());

    let v1_iter2: i32 = v1.iter().sum();
    println!("total is {}", v1_iter2);

    let v1_iter3 = v1.iter().map(|x| x*2);
    for i in v1_iter3 {
        println!("{}", i);
    }
    let v1_iter4: Vec<i32> = v1.iter().map(|x| x + 1).collect();
    println!("{:?}", v1_iter4);

    let c = Counter::new(10);
    // let c_iter = c.into_iter();
    for i in c {
        println!("{}", i);
    }
}