Function core::iter::repeat_with [−][src]
pub fn repeat_with<A, F: FnMut() -> A>(repeater: F) -> RepeatWith<F>
Creates a new iterator that repeats elements of type A endlessly by
applying the provided closure, the repeater, F: FnMut() -> A.
The repeat_with() function calls the repeater over and over and over and
over and over and 🔁.
Infinite iterators like repeat_with() are often used with adapters like
take, in order to make them finite.
If the element type of the iterator you need implements Clone, and
it is OK to keep the source element in memory, you should instead use
the repeat function.
An iterator produced by repeat_with() is a DoubleEndedIterator.
It is important to note that reversing repeat_with(f) will produce
the exact same sequence as the non-reversed iterator. In other words,
repeat_with(f).rev().collect::<Vec<_>>() is equivalent to
repeat_with(f).collect::<Vec<_>>().
Examples
Basic usage:
#![feature(iterator_repeat_with)] use std::iter; // let's assume we have some value of a type that is not `Clone` // or which don't want to have in memory just yet because it is expensive: #[derive(PartialEq, Debug)] struct Expensive; // a particular value forever: let mut things = iter::repeat_with(|| Expensive); assert_eq!(Some(Expensive), things.next()); assert_eq!(Some(Expensive), things.next()); assert_eq!(Some(Expensive), things.next()); assert_eq!(Some(Expensive), things.next()); assert_eq!(Some(Expensive), things.next());Run
Using mutation and going finite:
#![feature(iterator_repeat_with)] use std::iter; // From the zeroth to the third power of two: let mut curr = 1; let mut pow2 = iter::repeat_with(|| { let tmp = curr; curr *= 2; tmp }) .take(4); assert_eq!(Some(1), pow2.next()); assert_eq!(Some(2), pow2.next()); assert_eq!(Some(4), pow2.next()); assert_eq!(Some(8), pow2.next()); // ... and now we're done assert_eq!(None, pow2.next());Run