Struct Source 

pub struct Source<T> { /* private fields */ }

Implementations

impl<T: Send + 'static> Source<T>

pub fn from_iter<I: IntoIterator<Item = T> + Send + 'static>(iter: I) -> Self

where I::IntoIter: Send + 'static,

pub fn single(value: T) -> Self

pub fn empty() -> Self

pub fn repeat(value: T) -> Self

where T: Clone,

pub fn cycle<I: IntoIterator<Item = T> + Clone + Send + 'static>( iter: I, ) -> Self

where I::IntoIter: Send + 'static, T: Clone,

pub fn from_future<F>(fut: F) -> Self

where F: Future<Output = T> + Send + 'static,

pub fn unfold<S, F, Fut>(init: S, f: F) -> Self

where S: Send + 'static, F: FnMut(S) -> Fut + Send + 'static, Fut: Future<Output = Option<(T, S)>> + Send + 'static,

pub fn tick(initial_delay: Duration, interval: Duration, value: T) -> Self

where T: Clone,

pub fn failed<E>(error: E) -> Source<Result<T, E>>

where E: Send + 'static,

pub fn from_receiver(rx: UnboundedReceiver<T>) -> Self

pub fn map<U, F>(self, f: F) -> Source<U>

where F: FnMut(T) -> U + Send + 'static, U: Send + 'static,

pub fn map_async<U, F, Fut>(self, parallelism: usize, f: F) -> Source<U>

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

(ordered, bounded parallelism).

pub fn map_async_unordered<U, F, Fut>( self, parallelism: usize, f: F, ) -> Source<U>

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

pub fn async_boundary(self, buffer: usize) -> Source<T>

async_boundary(buffer) — explicit async stage that decouples the upstream and downstream pipelines onto separate Tokio tasks via a bounded mpsc channel of capacity buffer. the .async call. Phase 12.3 of docs/full-port-plan.md.

Useful when an upstream stage is CPU-heavy and you want downstream consumption to overlap with production. Slow downstream applies natural back-pressure once the buffer fills.

pub fn filter<F>(self, f: F) -> Source<T>

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

pub fn filter_map<U, F>(self, f: F) -> Source<U>

where F: FnMut(T) -> Option<U> + Send + 'static, U: Send + 'static,

pub fn take(self, n: usize) -> Source<T>

pub fn take_while<F>(self, f: F) -> Source<T>

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

pub fn skip(self, n: usize) -> Source<T>

pub fn skip_while<F>(self, f: F) -> Source<T>

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

pub fn scan<Acc, F>(self, init: Acc, f: F) -> Source<Acc>

where Acc: Clone + Send + 'static, F: FnMut(&Acc, T) -> Acc + Send + 'static,

pub fn grouped(self, n: usize) -> Source<Vec<T>>

Emit vectors of up to n items.

pub fn intersperse(self, sep: T) -> Source<T>

where T: Clone,

pub fn concat(self, other: Source<T>) -> Source<T>

pub fn prepend(self, other: Source<T>) -> Source<T>

pub fn delay(self, d: Duration) -> Source<T>

Shift every element by d.

pub fn initial_delay(self, d: Duration) -> Source<T>

Wait d before emitting the first element.

pub fn throttle(self, interval: Duration) -> Source<T>

Limit element rate (one per interval).

pub fn buffer(self, size: usize, strategy: OverflowStrategy) -> Source<T>

pub fn wire_tap<F>(self, f: F) -> Source<T>

where F: FnMut(&T) + Send + 'static,

Observes each element without affecting the stream.

pub fn via<U>(self, flow: Flow<T, U>) -> Source<U>

where U: Send + 'static,