Function std::iter::repeat_with

Important traits for RepeatWith<F>

impl<A, F> Iterator for RepeatWith<F> where
    F: FnMut() -> A,  type Item = A;

pub fn repeat_with<A, F>(repeater: F) -> RepeatWith<F> where
    F: FnMut() -> A, 

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 not a DoubleEndedIterator. If you need repeat_with() to return a DoubleEndedIterator, please open a GitHub issue explaining your use case.

Examples

Basic usage:

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());

Using mutation and going finite:

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());