Struct Flow 

pub struct Flow<In, Out> { /* private fields */ }

Implementations

impl<T: Send + 'static> Flow<T, T>

pub fn identity() -> Self

impl<In: Send + 'static, Out: Send + 'static> Flow<In, Out>

pub fn from_fn<F>(f: F) -> Self

where F: FnMut(In) -> Out + Send + 'static,

Pure synchronous mapping./ Select.

pub fn map_async<F, Fut>(parallelism: usize, f: F) -> Self

where F: FnMut(In) -> Fut + Send + 'static, Fut: Future<Output = Out> + Send + 'static,

Asynchronous mapping with ordered bounded parallelism.

pub fn via<Out2: Send + 'static>(self, next: Flow<Out, Out2>) -> Flow<In, Out2>

Chain another flow after this one.

pub fn then<Out2, F>(self, g: F) -> Flow<In, Out2>

where Out2: Send + 'static, F: FnMut(Out) -> Out2 + Send + 'static,

Compose with a post-processing closure./ Select.

impl<In: Send + 'static> Flow<In, In>

pub fn filter<F>(f: F) -> Self

where F: FnMut(&In) -> bool + Send + 'static,

pub fn take(n: usize) -> Self

pub fn skip(n: usize) -> Self

pub fn throttle(interval: Duration) -> Self

impl<In: Send + 'static, Out: Send + 'static> Flow<In, Out>

pub fn flat_map_concat<F, S, U>(f: F) -> Flow<In, U>

where F: FnMut(In) -> S + Send + 'static, S: IntoIterator<Item = U> + Send + 'static, S::IntoIter: Send + 'static, U: Send + 'static, In: 'static,

/ flatMapConcat.