cranelift_codegen/
iterators.rs

1//! Iterator utilities.
2
3/// Extra methods for iterators.
4pub trait IteratorExtras: Iterator {
5    /// Create an iterator that produces adjacent pairs of elements from the iterator.
6    fn adjacent_pairs(mut self) -> AdjacentPairs<Self>
7    where
8        Self: Sized,
9        Self::Item: Clone,
10    {
11        let elem = self.next();
12        AdjacentPairs { iter: self, elem }
13    }
14}
15
16impl<T> IteratorExtras for T where T: Iterator {}
17
18/// Adjacent pairs iterator returned by `adjacent_pairs()`.
19///
20/// This wraps another iterator and produces a sequence of adjacent pairs of elements.
21pub struct AdjacentPairs<I>
22where
23    I: Iterator,
24    I::Item: Clone,
25{
26    iter: I,
27    elem: Option<I::Item>,
28}
29
30impl<I> Iterator for AdjacentPairs<I>
31where
32    I: Iterator,
33    I::Item: Clone,
34{
35    type Item = (I::Item, I::Item);
36
37    fn next(&mut self) -> Option<Self::Item> {
38        self.elem.take().and_then(|e| {
39            self.elem = self.iter.next();
40            self.elem.clone().map(|n| (e, n))
41        })
42    }
43}
44
45#[cfg(test)]
46mod tests {
47    use alloc::vec::Vec;
48
49    #[test]
50    fn adjpairs() {
51        use super::IteratorExtras;
52
53        assert_eq!(
54            [1, 2, 3, 4]
55                .iter()
56                .cloned()
57                .adjacent_pairs()
58                .collect::<Vec<_>>(),
59            vec![(1, 2), (2, 3), (3, 4)]
60        );
61        assert_eq!(
62            [2, 3, 4]
63                .iter()
64                .cloned()
65                .adjacent_pairs()
66                .collect::<Vec<_>>(),
67            vec![(2, 3), (3, 4)]
68        );
69        assert_eq!(
70            [2, 3, 4]
71                .iter()
72                .cloned()
73                .adjacent_pairs()
74                .collect::<Vec<_>>(),
75            vec![(2, 3), (3, 4)]
76        );
77        assert_eq!(
78            [3, 4].iter().cloned().adjacent_pairs().collect::<Vec<_>>(),
79            vec![(3, 4)]
80        );
81        assert_eq!(
82            [4].iter().cloned().adjacent_pairs().collect::<Vec<_>>(),
83            vec![]
84        );
85        assert_eq!(
86            [].iter()
87                .cloned()
88                .adjacent_pairs()
89                .collect::<Vec<(i32, i32)>>(),
90            vec![]
91        );
92    }
93}