Struct Sink 

pub struct Sink<In, Mat> { /* private fields */ }

Implementations

impl<T: Send + 'static> Sink<T, SinkQueue<T>>

pub fn queue() -> Self

impl<In: Send + 'static, Mat: Send + 'static> Sink<In, Mat>

pub fn run_with<SourceMat: Send + 'static>( self, source: Source<In, SourceMat>, ) -> StreamResult<SourceMat>

pub fn run_with_materializer<SourceMat: Send + 'static>( self, source: Source<In, SourceMat>, materializer: &Materializer, ) -> StreamResult<SourceMat>

pub fn from_materializer<F>(factory: F) -> Self

where F: Fn(&Materializer, &Attributes) -> Sink<In, Mat> + Send + Sync + 'static,

pub fn setup<F>(factory: F) -> Self

where F: Fn(&Materializer, &Attributes) -> Sink<In, Mat> + Send + Sync + 'static,

pub fn pre_materialize( &self, materializer: &Materializer, ) -> StreamResult<(Mat, Sink<In, NotUsed>)>

pub fn map_materialized_value<NextMat, F>(self, f: F) -> Sink<In, NextMat>

where NextMat: Send + 'static, F: Fn(Mat) -> NextMat + Send + Sync + 'static,

pub fn attributes(&self) -> &Attributes

pub fn with_attributes(self, attributes: Attributes) -> Self

pub fn add_attributes(self, attributes: Attributes) -> Self

pub fn named(self, name: impl Into<String>) -> Self

impl<In: Clone + Send + 'static> Sink<In, NotUsed>

pub fn combine<M1, M2, MRest, I>( first: Sink<In, M1>, second: Sink<In, M2>, rest: I, strategy: SinkCombineStrategy, ) -> Sink<In, NotUsed>

where M1: Send + 'static, M2: Send + 'static, MRest: Send + 'static, I: IntoIterator<Item = Sink<In, MRest>>,

impl<In: Send + 'static> Sink<In, StreamCompletion<Vec<In>>>

pub fn collect() -> Self

pub fn collection() -> Self

pub fn take_last(n: usize) -> Self

impl<In: Send + 'static> Sink<In, StreamCompletion<NotUsed>>

pub fn ignore() -> Self

pub fn on_complete<F>(callback: F) -> Self

where F: FnOnce() + Send + Sync + 'static,

pub fn never() -> Self

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

where F: Fn(In) + Send + Sync + 'static,

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

where F: Fn(In) -> Fut + Send + Sync + 'static, Fut: Future<Output = StreamResult<()>> + Send + 'static,

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

where F: Fn(In) -> StreamResult<()> + Send + Sync + 'static,

pub fn foreach_result_with_supervision<F>( f: F, decider: SupervisionDecider, ) -> Self

where F: Fn(In) -> StreamResult<()> + Send + Sync + 'static,

impl<In: Send + 'static> Sink<In, StreamCompletion<In>>

pub fn head() -> Self

Materializes a sink that completes with the stream’s first element, or fails with StreamError::EmptyStream if the stream is empty.

Fed by a synchronous bounded eager source (Source::single/from_iter/ empty/failed, optionally through inline-preserving synchronous flows such as map/filter/identity), this terminal takes the inline head fast path: the first element is produced on the calling thread during materialization, without spawning a worker or a oneshot channel. As a result run_with_materializer() blocks until that element is available and the returned StreamCompletion is already resolved, so any work a caller expected to overlap between run_with_materializer() returning and .wait() is already done for these sources. Other sources — and any chain that passes through a non-preserving operator, including ActorFlow::ask (whose blocking cross-thread reply wait must not run inline on the caller) — still drain on a runtime worker as before, keeping the returned StreamCompletion non-blocking/awaitable.

pub fn last() -> Self

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

where F: Fn(In, In) -> In + Send + Sync + 'static,

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

where F: Fn(In, In) -> StreamResult<In> + Send + Sync + 'static,

pub fn reduce_result_with_supervision<F>( f: F, decider: SupervisionDecider, ) -> Self

where In: Clone, F: Fn(In, In) -> StreamResult<In> + Send + Sync + 'static,

impl<In: Send + 'static> Sink<In, StreamCompletion<Option<In>>>

pub fn head_option() -> Self

Materializes a sink that completes with Some(first element), or None if the stream is empty.

Like Sink::head, fed by a synchronous bounded eager source (Source::single/from_iter/empty/failed, optionally through inline-preserving synchronous flows such as map/filter/identity) this terminal takes the inline head fast path: the result is produced on the calling thread during materialization without spawning a worker or a oneshot channel, so run_with_materializer() blocks until it is available and the returned StreamCompletion is already resolved. Any work a caller expected to overlap between run_with_materializer() returning and .wait() is already done for these sources; other sources — and any chain through a non-preserving operator, including ActorFlow::ask (whose blocking cross-thread reply wait must not run inline) — still drain on a runtime worker, keeping the returned StreamCompletion non-blocking/awaitable.

pub fn last_option() -> Self

impl<In: Send + 'static> Sink<In, NotUsed>

pub fn cancelled() -> Self

pub fn future_sink<InnerMat, F, Fut>( future: F, ) -> Sink<In, StreamCompletion<InnerMat>>

where InnerMat: Send + 'static, F: Fn() -> Fut + Send + Sync + 'static, Fut: Future<Output = StreamResult<Sink<In, InnerMat>>> + Send + 'static,

pub fn lazy_sink<InnerMat, F>(create: F) -> Sink<In, StreamCompletion<InnerMat>>

where InnerMat: Send + 'static, F: Fn() -> Sink<In, InnerMat> + Send + Sync + 'static,

pub fn lazy_future_sink<InnerMat, F, Fut>( create: F, ) -> Sink<In, StreamCompletion<InnerMat>>

where InnerMat: Send + 'static, F: Fn() -> Fut + Send + Sync + 'static, Fut: Future<Output = StreamResult<Sink<In, InnerMat>>> + Send + 'static,

pub fn fold<Acc, F>(zero: Acc, f: F) -> Sink<In, StreamCompletion<Acc>>

where Acc: Clone + Send + Sync + 'static, F: Fn(Acc, In) -> Acc + Send + Sync + 'static,

pub fn fold_result<Acc, F>(zero: Acc, f: F) -> Sink<In, StreamCompletion<Acc>>

where Acc: Clone + Send + Sync + 'static, F: Fn(Acc, In) -> StreamResult<Acc> + Send + Sync + 'static,

pub fn fold_result_with_supervision<Acc, F>( zero: Acc, f: F, decider: SupervisionDecider, ) -> Sink<In, StreamCompletion<Acc>>

where Acc: Clone + Send + Sync + 'static, F: Fn(Acc, In) -> StreamResult<Acc> + Send + Sync + 'static,

Trait Implementations

impl<In, Mat> Clone for Sink<In, Mat>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.