loopable 0.1.0

Demo upload: do not use this crate
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

// Combinator test 

// iterator that uses another iterator and skips
//    every other value from inner iterator
pub struct SkipIterator<I: Iterator> {
    inner: I,
}

impl<I, T> Iterator for SkipIterator<I> 
                where I: Iterator<Item = T> {
    type Item = T;
    fn next(&mut self) -> Option<Self::Item> {
        self.inner.next()?;
        self.inner.next()
    }
}

pub trait IterCombi: Iterator + Sized {
    fn skip_half(self) -> SkipIterator<Self> {
        SkipIterator { inner: self }
    }
}

impl<I: Iterator + Sized> IterCombi for I {}






#[cfg(test)]
mod combi_tests {
    use super::*;

    use itertools::Itertools;

    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }

    #[test]
    fn skip_iter_test() {
        // create a basic iterator using range
        //   and step_by()
        let my_iter = (2..13).step_by(2);
        
        // make new iterator using SkipIterator
        let skip_iter = my_iter.skip_half();

        let mut sum = 0;
        for s in skip_iter {
            println!("s, sum = {}, {}", s, sum);
            sum += s;
        }
        assert_eq!(sum, 24, "Test 1");
        
    }


    #[test]
    fn skip_iter_2() {
        // create a basic iterator using range
        //   and step_by()
        // let my_iter = (2..13).step_by(2);
        
        // make new iterator using SkipIterator
        // 
        //let skip_sum: i32 = my_iter.skip_half().sum();
        
        let skip_sum: i32 = (2..13).step_by(2).skip_half().sum();

        assert_eq!(skip_sum, 24, "Test 1");
        
    }

    #[test]
    fn test_step_by() {
        let v: i32 = (0..10).step_by(3).sum();
        assert_eq!(v, 0 + 3 + 6 + 9);
    }

    #[test]
    fn test_interleave() {
        let v:Vec<i32> = (0..4).interleave((10..14).rev()).collect();
        assert_eq!(v, vec![0, 13, 1, 12, 2, 11, 3, 10]);
    }

    #[test]
    fn test_intersperse() {
        let s = "hello world etc";
        // split(" ") - get iterator for string split at space
        //  intersperse - puts item between next iterator elements
        //    not after last item
        let v : Vec<&str> = s.split(" ").intersperse(",").collect();
    
        assert_eq!(v, vec!["hello",",","world",",","etc"]);
    
        let s2 = s.split(" ").join(",");
        assert_eq!(s2, "hello,world,etc");
    }
}