1 //! Licensed under the Apache License, Version 2.0
2 //! http://www.apache.org/licenses/LICENSE-2.0 or the MIT license
3 //! http://opensource.org/licenses/MIT, at your
4 //! option. This file may not be copied, modified, or distributed
5 //! except according to those terms.
8 #[macro_use] extern crate itertools as it;
15 use it
::free
::put_back
;
21 let mut prod
= iproduct
!(s
.chars(), 0..2);
22 assert
!(prod
.next() == Some(('α'
, 0)));
23 assert
!(prod
.next() == Some(('α'
, 1)));
24 assert
!(prod
.next() == Some(('β'
, 0)));
25 assert
!(prod
.next() == Some(('β'
, 1)));
26 assert
!(prod
.next() == None
);
30 fn product_temporary() {
31 for (_x
, _y
, _z
) in iproduct
!(
32 [0, 1, 2].iter().cloned(),
33 [0, 1, 2].iter().cloned(),
34 [0, 1, 2].iter().cloned())
43 let mut zip
= izip
!(2..3);
44 assert
!(zip
.next() == Some(2));
45 assert
!(zip
.next().is_none());
47 let mut zip
= izip
!(0..3, 0..2, 0..2i8);
49 assert
!((i
as usize, i
, i
as i8) == zip
.next().unwrap());
51 assert
!(zip
.next().is_none());
53 let xs
: [isize; 0] = [];
54 let mut zip
= izip
!(0..3, 0..2, 0..2i8, &xs
);
55 assert
!(zip
.next().is_none());
60 let _zip1
: iter
::Zip
<_
, _
> = izip
!(1.., 2..);
61 let _zip2
: iter
::Zip
<_
, _
> = izip
!(1.., 2.., );
66 let mut zip
: iter
::Map
<iter
::Zip
<_
, _
>, _
> = izip
!(0..3, 0..2, 0..2i8);
68 assert
!((i
as usize, i
, i
as i8) == zip
.next().unwrap());
70 assert
!(zip
.next().is_none());
75 let mut zip
= multizip((0..3, 0..2, 0..2i8));
77 assert
!((i
as usize, i
, i
as i8) == zip
.next().unwrap());
79 assert
!(zip
.next().is_none());
81 let xs
: [isize; 0] = [];
82 let mut zip
= multizip((0..3, 0..2, 0..2i8, xs
.iter()));
83 assert
!(zip
.next().is_none());
85 for (_
, _
, _
, _
, _
) in multizip((0..3, 0..2, xs
.iter(), &xs
, xs
.to_vec())) {
94 let cnt
= ys
.iter_mut().set_from(xs
.iter().map(|x
| *x
));
95 assert
!(cnt
== xs
.len());
96 assert
!(ys
== [7, 9, 8, 0, 0]);
98 let cnt
= ys
.iter_mut().set_from(0..10);
99 assert
!(cnt
== ys
.len());
100 assert
!(ys
== [0, 1, 2, 3, 4]);
104 fn test_interleave() {
105 let xs
: [u8; 0] = [];
106 let ys
= [7u8, 9, 8, 10];
108 let it
= interleave(xs
.iter(), ys
.iter());
109 it
::assert_equal(it
, ys
.iter());
111 let rs
= [7u8, 2, 9, 77, 8, 10];
112 let it
= interleave(ys
.iter(), zs
.iter());
113 it
::assert_equal(it
, rs
.iter());
119 let xs
= [1i32, 2, 3];
121 xs
.iter().foreach(|elt
| sum
+= *elt
);
128 let mut it
= xs
.iter().dropping(2);
129 assert_eq
!(it
.next(), Some(&3));
130 assert
!(it
.next().is_none());
131 let mut it
= xs
.iter().dropping(5);
132 assert
!(it
.next().is_none());
137 let xs
= [0, 1, 2, 1, 3];
138 let ys
= [(0, 1), (2, 1)];
140 // An iterator that gathers elements up in pairs
141 let pit
= xs
.iter().cloned().batching(|it
| {
144 Some(x
) => match it
.next() {
146 Some(y
) => Some((x
, y
)),
150 it
::assert_equal(pit
, ys
.iter().cloned());
155 let xs
= [0, 1, 1, 1, 2, 1, 3, 3];
156 let mut pb
= put_back(xs
.iter().cloned());
160 it
::assert_equal(pb
, xs
.iter().cloned());
166 it
::assert_equal((0..10).step(1), 0..10);
167 it
::assert_equal((0..10).step(2), (0..10).filter(|x
: &i32| *x
% 2 == 0));
168 it
::assert_equal((0..10).step(10), 0..1);
174 it
::assert_equal((0..10).step(2).merge((1..10).step(2)), 0..10);
181 let mut it
= it
::repeat_n(s
, 3);
182 assert_eq
!(it
.len(), 3);
183 assert_eq
!(it
.next(), Some(s
));
184 assert_eq
!(it
.next(), Some(s
));
185 assert_eq
!(it
.next(), Some(s
));
186 assert_eq
!(it
.next(), None
);
187 assert_eq
!(it
.next(), None
);
192 // Check that RepeatN only clones N - 1 times.
194 use core
::cell
::Cell
;
195 #[derive(PartialEq, Debug)]
202 fn clone(&self) -> Self
204 let n
= self.n
.get();
206 Foo { n: Cell::new(n + 1) }
212 let f
= Foo{n: Cell::new(0)}
;
213 let it
= it
::repeat_n(f
, n
);
215 let last
= it
.last();
217 assert_eq
!(last
, None
);
219 assert_eq
!(last
, Some(Foo{n: Cell::new(n - 1)}
));
226 let mut data
= [7, 1, 1, 9, 1, 1, 3];
227 let i
= it
::partition(&mut data
, |elt
| *elt
>= 3);
229 assert_eq
!(data
, [7, 3, 9, 1, 1, 1, 1]);
231 let i
= it
::partition(&mut data
, |elt
| *elt
== 1);
233 assert_eq
!(data
, [1, 1, 1, 1, 9, 3, 7]);
235 let mut data
= [1, 2, 3, 4, 5, 6, 7, 8, 9];
236 let i
= it
::partition(&mut data
, |elt
| *elt
% 3 == 0);
238 assert_eq
!(data
, [9, 6, 3, 4, 5, 2, 7, 8, 1]);
244 assert_eq
!((0..i
).tree_fold1(|x
, y
| x
+ y
), (0..i
).fold1(|x
, y
| x
+ y
));