core/iter/adapters/
cycle.rs

1use crate::iter::FusedIterator;
2use crate::num::NonZero;
3use crate::ops::Try;
4
5/// An iterator that repeats endlessly.
6///
7/// This `struct` is created by the [`cycle`] method on [`Iterator`]. See its
8/// documentation for more.
9///
10/// [`cycle`]: Iterator::cycle
11/// [`Iterator`]: trait.Iterator.html
12#[derive(Clone, Debug)]
13#[must_use = "iterators are lazy and do nothing unless consumed"]
14#[stable(feature = "rust1", since = "1.0.0")]
15pub struct Cycle<I> {
16    orig: I,
17    iter: I,
18}
19
20#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
21const impl<I: [const] Clone> Cycle<I> {
22    pub(in crate::iter) fn new(iter: I) -> Cycle<I> {
23        Cycle { orig: iter.clone(), iter }
24    }
25}
26
27#[stable(feature = "rust1", since = "1.0.0")]
28impl<I> Iterator for Cycle<I>
29where
30    I: Clone + Iterator,
31{
32    type Item = <I as Iterator>::Item;
33
34    #[inline]
35    fn next(&mut self) -> Option<<I as Iterator>::Item> {
36        match self.iter.next() {
37            None => {
38                self.iter = self.orig.clone();
39                self.iter.next()
40            }
41            y => y,
42        }
43    }
44
45    #[inline]
46    fn size_hint(&self) -> (usize, Option<usize>) {
47        // the cycle iterator is either empty or infinite
48        match self.orig.size_hint() {
49            sz @ (0, Some(0)) => sz,
50            (0, _) => (0, None),
51            _ => (usize::MAX, None),
52        }
53    }
54
55    #[inline]
56    fn try_fold<Acc, F, R>(&mut self, mut acc: Acc, mut f: F) -> R
57    where
58        F: FnMut(Acc, Self::Item) -> R,
59        R: Try<Output = Acc>,
60    {
61        // fully iterate the current iterator. this is necessary because
62        // `self.iter` may be empty even when `self.orig` isn't
63        acc = self.iter.try_fold(acc, &mut f)?;
64        self.iter = self.orig.clone();
65
66        // complete a full cycle, keeping track of whether the cycled
67        // iterator is empty or not. we need to return early in case
68        // of an empty iterator to prevent an infinite loop
69        let mut is_empty = true;
70        acc = self.iter.try_fold(acc, |acc, x| {
71            is_empty = false;
72            f(acc, x)
73        })?;
74
75        if is_empty {
76            return try { acc };
77        }
78
79        loop {
80            self.iter = self.orig.clone();
81            acc = self.iter.try_fold(acc, &mut f)?;
82        }
83    }
84
85    #[inline]
86    #[rustc_inherit_overflow_checks]
87    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
88        let mut n = match self.iter.advance_by(n) {
89            Ok(()) => return Ok(()),
90            Err(rem) => rem.get(),
91        };
92
93        while n > 0 {
94            self.iter = self.orig.clone();
95            n = match self.iter.advance_by(n) {
96                Ok(()) => return Ok(()),
97                e @ Err(rem) if rem.get() == n => return e,
98                Err(rem) => rem.get(),
99            };
100        }
101
102        NonZero::new(n).map_or(Ok(()), Err)
103    }
104
105    // No `fold` override, because `fold` doesn't make much sense for `Cycle`,
106    // and we can't do anything better than the default.
107}
108
109#[stable(feature = "fused", since = "1.26.0")]
110impl<I> FusedIterator for Cycle<I> where I: Clone + Iterator {}
core/iter/adapters/cycle.rs

core/iter/adapters/
cycle.rs
