Function polkadot_node_subsystem::gen::futures::prelude::stream::repeat_with

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

Creates a new stream 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 again.

Infinite stream like repeat_with() are often used with adapters like [stream.take()], in order to make them finite.

If the element type of the stream you need implements Clone, and it is OK to keep the source element in memory, you should instead use the [stream.repeat()] function.

Examples

Basic usage:

use futures::stream::{self, StreamExt};

// 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 = stream::repeat_with(|| Expensive);

assert_eq!(Some(Expensive), things.next().await);
assert_eq!(Some(Expensive), things.next().await);
assert_eq!(Some(Expensive), things.next().await);

Using mutation and going finite:

use futures::stream::{self, StreamExt};

// From the zeroth to the third power of two:
let mut curr = 1;
let mut pow2 = stream::repeat_with(|| { let tmp = curr; curr *= 2; tmp })
                    .take(4);

assert_eq!(Some(1), pow2.next().await);
assert_eq!(Some(2), pow2.next().await);
assert_eq!(Some(4), pow2.next().await);
assert_eq!(Some(8), pow2.next().await);

// ... and now we're done
assert_eq!(None, pow2.next().await);