Struct Stream 

pub struct Stream<E, A> { /* private fields */ }

An effectful stream producing values of type A.

Pull-based: each step is an Io that produces either the next value and the rest of the stream, or None.

Implementations

impl<E: Send + 'static, A: Send + 'static> Stream<E, A>

pub fn empty() -> Self

An empty stream.

pub fn emit(a: A) -> Self

A stream that emits a single value.

pub fn from_vec(items: Vec<A>) -> Self

Build a stream from a Vec of values.

pub fn unfold<S: Send + 'static>( init: S, step: Arc<dyn Fn(S) -> Io<E, Option<(A, S)>> + Send + Sync>, ) -> Self

Build a stream by repeatedly applying a step function to state.

The step function returns None to end the stream, or Some((value, next_state)) to emit and continue.

pub fn from_io(io: Io<E, A>) -> Self

Lift a single Io into a one-element stream.

pub fn map<B: Send + 'static>( self, f: Arc<dyn Fn(A) -> B + Send + Sync>, ) -> Stream<E, B>

Apply a function to each element.

pub fn concat(self, other: Stream<E, A>) -> Self

Append another stream after this one.

pub fn take(self, n: usize) -> Self

Take at most n elements.

pub fn fold<B: Send + 'static>( self, init: B, f: Arc<dyn Fn(B, A) -> B + Send + Sync>, ) -> Io<E, B>

Collapse the stream into a single value via a folding function.

This is the primary way to “run” a stream, producing an Io.

pub fn collect(self) -> Io<E, Vec<A>>

Collect all stream elements into a Vec.