Struct Flow 

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

Implementations

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

pub fn identity() -> Self

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

pub fn from_sink_and_source<InMat, OutMat>( sink: Sink<In, InMat>, source: Source<Out, OutMat>, ) -> Self

where InMat: Send + 'static, OutMat: Send + 'static,

pub fn from_sink_and_source_coupled<InMat, OutMat>( sink: Sink<In, InMat>, source: Source<Out, OutMat>, ) -> Self

where InMat: Send + 'static, OutMat: Send + 'static,

pub fn future_flow<InnerMat, F, Fut>( future: F, ) -> Flow<In, Out, StreamCompletion<InnerMat>>

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

pub fn lazy_flow<InnerMat, F>( create: F, ) -> Flow<In, Out, StreamCompletion<InnerMat>>

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

pub fn lazy_future_flow<InnerMat, F, Fut>( create: F, ) -> Flow<In, Out, StreamCompletion<InnerMat>>

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

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

pub fn as_flow_with_context<U, CtxIn, CtxOut, Collapse, Extract>( self, collapse_context: Collapse, extract_context: Extract, ) -> FlowWithContext<U, CtxIn, Out, CtxOut, Mat>

where U: Send + 'static, CtxIn: Send + 'static, CtxOut: Send + 'static, Collapse: Fn(U, CtxIn) -> In + Send + Sync + 'static, Extract: Fn(&Out) -> CtxOut + 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

pub fn via<Next, NextMat>( self, next: Flow<Out, Next, NextMat>, ) -> Flow<In, Next, Mat>

where Next: Send + 'static, NextMat: Send + 'static,

pub fn via_mat<Next, NextMat, Combined, F>( self, next: Flow<Out, Next, NextMat>, combine: F, ) -> Flow<In, Next, Combined>

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

pub fn via_mat_with<Next, NextMat, Combined, F>( self, next: Flow<Out, Next, NextMat>, combine: F, ) -> Flow<In, Next, Combined>

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

pub fn map<Next, F>(self, f: F) -> Flow<In, Next, Mat>

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

pub fn map_result<Next, F>(self, f: F) -> Flow<In, Next, Mat>

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

Fallible map. An error stops the stream, matching Datum’s existing default supervision behavior.

pub fn map_result_with_supervision<Next, F>( self, f: F, decider: SupervisionDecider, ) -> Flow<In, Next, Mat>

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

Fallible map with an Akka-style supervision decider.

Resume drops the failing element. Restart is equivalent to Resume for stateless map.

pub fn filter<F>(self, predicate: F) -> Flow<In, Out, Mat>

where F: Fn(&Out) -> bool + Send + Sync + 'static,

pub fn filter_result<F>(self, predicate: F) -> Flow<In, Out, Mat>

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

pub fn filter_result_with_supervision<F>( self, predicate: F, decider: SupervisionDecider, ) -> Flow<In, Out, Mat>

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

pub fn filter_not<F>(self, predicate: F) -> Flow<In, Out, Mat>

where F: Fn(&Out) -> bool + Send + Sync + 'static,

pub fn filter_map<Next, F>(self, f: F) -> Flow<In, Next, Mat>

where Next: Send + 'static, F: Fn(Out) -> Option<Next> + Send + Sync + 'static,

pub fn filter_map_result<Next, F>(self, f: F) -> Flow<In, Next, Mat>

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

pub fn filter_map_result_with_supervision<Next, F>( self, f: F, decider: SupervisionDecider, ) -> Flow<In, Next, Mat>

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

pub fn map_concat<Next, F, I>(self, f: F) -> Flow<In, Next, Mat>

where Next: Send + 'static, F: Fn(Out) -> I + Send + Sync + 'static, I: IntoIterator<Item = Next>, I::IntoIter: Send + 'static,

pub fn map_concat_result<Next, F, I>(self, f: F) -> Flow<In, Next, Mat>

where Next: Send + 'static, F: Fn(Out) -> StreamResult<I> + Send + Sync + 'static, I: IntoIterator<Item = Next>, I::IntoIter: Send + 'static,

pub fn map_concat_result_with_supervision<Next, F, I>( self, f: F, decider: SupervisionDecider, ) -> Flow<In, Next, Mat>

where Next: Send + 'static, F: Fn(Out) -> StreamResult<I> + Send + Sync + 'static, I: IntoIterator<Item = Next>, I::IntoIter: Send + 'static,

pub fn stateful_map<State, Next, F>( self, seed: State, f: F, ) -> Flow<In, Next, Mat>

where State: Clone + Send + Sync + 'static, Next: Send + 'static, F: Fn(&mut State, Out) -> Next + Send + Sync + 'static,

pub fn stateful_map_result<State, Next, F>( self, seed: State, f: F, ) -> Flow<In, Next, Mat>

where State: Clone + Send + Sync + 'static, Next: Send + 'static, F: Fn(&mut State, Out) -> StreamResult<Next> + Send + Sync + 'static,

pub fn stateful_map_result_with_supervision<State, Next, F>( self, seed: State, f: F, decider: SupervisionDecider, ) -> Flow<In, Next, Mat>

where State: Clone + Send + Sync + 'static, Next: Send + 'static, F: Fn(&mut State, Out) -> StreamResult<Next> + Send + Sync + 'static,

pub fn stateful_map_concat<State, Next, F, I>( self, seed: State, f: F, ) -> Flow<In, Next, Mat>

where State: Clone + Send + Sync + 'static, Next: Send + 'static, F: Fn(&mut State, Out) -> I + Send + Sync + 'static, I: IntoIterator<Item = Next>, I::IntoIter: Send + 'static,

pub fn stateful_map_concat_result<State, Next, F, I>( self, seed: State, f: F, ) -> Flow<In, Next, Mat>

where State: Clone + Send + Sync + 'static, Next: Send + 'static, F: Fn(&mut State, Out) -> StreamResult<I> + Send + Sync + 'static, I: IntoIterator<Item = Next>, I::IntoIter: Send + 'static,

pub fn stateful_map_concat_result_with_supervision<State, Next, F, I>( self, seed: State, f: F, decider: SupervisionDecider, ) -> Flow<In, Next, Mat>

where State: Clone + Send + Sync + 'static, Next: Send + 'static, F: Fn(&mut State, Out) -> StreamResult<I> + Send + Sync + 'static, I: IntoIterator<Item = Next>, I::IntoIter: Send + 'static,

pub fn map_async<Next, F, Fut>( self, parallelism: usize, f: F, ) -> Flow<In, Next, Mat>

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

Polls each future once on the drain thread and moves only pending futures onto the Tokio runtime. Contract-conforming futures behave identically across that handoff; futures must not block inside poll.

pub fn map_async_with_supervision<Next, F, Fut>( self, parallelism: usize, f: F, decider: SupervisionDecider, ) -> Flow<In, Next, Mat>

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

Fallible map_async with an Akka-style supervision decider.

Resume and Restart drop the failed future result and keep the ordered output sequence moving. Upstream errors are not supervised.

pub fn map_async_unordered<Next, F, Fut>( self, parallelism: usize, f: F, ) -> Flow<In, Next, Mat>

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

Polls each future once on the drain thread and moves only pending futures onto the Tokio runtime. Contract-conforming futures behave identically across that handoff; futures must not block inside poll.

pub fn map_async_unordered_with_supervision<Next, F, Fut>( self, parallelism: usize, f: F, decider: SupervisionDecider, ) -> Flow<In, Next, Mat>

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

pub fn map_async_partitioned<Key, Next, Partition, F, Fut>( self, parallelism: usize, per_partition: usize, partition: Partition, f: F, ) -> Flow<In, Next, Mat>

where Key: Clone + Eq + Hash + Send + 'static, Next: Send + 'static, Partition: Fn(&Out) -> Key + Send + Sync + 'static, F: Fn(Out) -> Fut + Send + Sync + 'static, Fut: Future<Output = StreamResult<Next>> + Send + 'static,

Polls each future once on the drain thread and moves only pending futures onto the Tokio runtime. Contract-conforming futures behave identically across that handoff; futures must not block inside poll.

pub fn take(self, n: usize) -> Flow<In, Out, Mat>

pub fn drop(self, n: usize) -> Flow<In, Out, Mat>

pub fn take_while<F>(self, predicate: F) -> Flow<In, Out, Mat>

where F: Fn(&Out) -> bool + Send + Sync + 'static,

pub fn drop_while<F>(self, predicate: F) -> Flow<In, Out, Mat>

where F: Fn(&Out) -> bool + Send + Sync + 'static,

pub fn limit(self, max: u64) -> Flow<In, Out, Mat>

pub fn grouped(self, size: usize) -> Flow<In, Vec<Out>, Mat>

pub fn scan<State, F>(self, seed: State, f: F) -> Flow<In, State, Mat>

where State: Clone + Send + Sync + 'static, F: Fn(State, Out) -> State + Send + Sync + 'static,

pub fn scan_async<State, F, Fut>( self, seed: State, f: F, ) -> Flow<In, State, Mat>

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

pub fn scan_result<State, F>(self, seed: State, f: F) -> Flow<In, State, Mat>

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

pub fn scan_result_with_supervision<State, F>( self, seed: State, f: F, decider: SupervisionDecider, ) -> Flow<In, State, Mat>

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

pub fn sliding(self, size: usize, step: usize) -> Flow<In, Vec<Out>, Mat>

where Out: Clone,

pub fn fold<Acc, F>(self, zero: Acc, f: F) -> Flow<In, Acc, Mat>

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

pub fn fold_async<Acc, F, Fut>(self, zero: Acc, f: F) -> Flow<In, Acc, Mat>

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

pub fn map_with_resource<Resource, Next, Create, F, Close>( self, create: Create, f: F, close: Close, ) -> Flow<In, Next, Mat>

where Resource: Send + 'static, Next: Send + 'static, Create: Fn() -> StreamResult<Resource> + Send + Sync + 'static, F: Fn(&mut Resource, Out) -> StreamResult<Next> + Send + Sync + 'static, Close: Fn(Resource) -> StreamResult<Option<Next>> + Send + Sync + 'static,

pub fn fold_result<Acc, F>(self, zero: Acc, f: F) -> Flow<In, Acc, Mat>

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

pub fn fold_result_with_supervision<Acc, F>( self, zero: Acc, f: F, decider: SupervisionDecider, ) -> Flow<In, Acc, Mat>

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

pub fn reduce<F>(self, f: F) -> Flow<In, Out, Mat>

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

pub fn reduce_result<F>(self, f: F) -> Flow<In, Out, Mat>

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

pub fn reduce_result_with_supervision<F>( self, f: F, decider: SupervisionDecider, ) -> Flow<In, Out, Mat>

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

pub fn map_error<F>(self, f: F) -> Flow<In, Out, Mat>

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

pub fn recover<F>(self, f: F) -> Flow<In, Out, Mat>

where F: Fn(StreamError) -> Option<Out> + Send + Sync + 'static,

pub fn recover_with<F>(self, f: F) -> Flow<In, Out, Mat>

where F: Fn(StreamError) -> Option<Source<Out>> + Send + Sync + 'static,

pub fn recover_with_retries<F>(self, retries: usize, f: F) -> Flow<In, Out, Mat>

where F: Fn(StreamError) -> Option<Source<Out>> + Send + Sync + 'static,

pub fn on_error_complete(self) -> Flow<In, Out, Mat>

pub fn prefix_and_tail(self, n: usize) -> Flow<In, (Vec<Out>, Source<Out>), Mat>

pub fn flat_map_prefix<Next, NextMat, F>( self, n: usize, f: F, ) -> Flow<In, Next, Mat>

where Next: Send + 'static, NextMat: Send + 'static, F: Fn(Vec<Out>) -> Flow<Out, Next, NextMat> + Send + Sync + 'static, Out: Clone,

pub fn group_by<Key, F>( self, max_substreams: usize, f: F, allow_closed_substream_recreation: bool, ) -> Flow<In, Source<Out>, Mat>

where Key: Clone + Eq + Hash + Send + 'static, F: Fn(&Out) -> Key + Send + Sync + 'static, Out: Clone,

pub fn split_when<F>(self, predicate: F) -> Flow<In, Source<Out>, Mat>

where F: Fn(&Out) -> bool + Send + Sync + 'static, Out: Clone,

pub fn split_after<F>(self, predicate: F) -> Flow<In, Source<Out>, Mat>

where F: Fn(&Out) -> bool + Send + Sync + 'static, Out: Clone,

pub fn flat_map_concat<Next, NextMat, F>(self, f: F) -> Flow<In, Next, Mat>

where Next: Send + 'static, NextMat: Send + 'static, F: Fn(Out) -> Source<Next, NextMat> + Send + Sync + 'static,

pub fn flat_map_merge<Next, NextMat, F>( self, breadth: usize, f: F, ) -> Flow<In, Next, Mat>

where Next: Send + 'static, NextMat: Send + 'static, F: Fn(Out) -> Source<Next, NextMat> + Send + Sync + 'static,

pub fn concat<Mat2>(self, that: Source<Out, Mat2>) -> Flow<In, Out, Mat>

where Mat2: Send + 'static,

pub fn concat_lazy<Mat2>(self, that: Source<Out, Mat2>) -> Flow<In, Out, Mat>

where Mat2: Send + 'static,

pub fn concat_all_lazy<Mat2, I>(self, those: I) -> Flow<In, Out, Mat>

where Mat2: Send + 'static, I: IntoIterator<Item = Source<Out, Mat2>>,

pub fn prepend<Mat2>(self, that: Source<Out, Mat2>) -> Flow<In, Out, Mat>

where Mat2: Send + 'static,

pub fn prepend_lazy<Mat2>(self, that: Source<Out, Mat2>) -> Flow<In, Out, Mat>

where Mat2: Send + 'static,

pub fn or_else<Mat2>(self, secondary: Source<Out, Mat2>) -> Flow<In, Out, Mat>

where Mat2: Send + 'static,

pub fn interleave<Mat2>( self, that: Source<Out, Mat2>, segment_size: usize, ) -> Flow<In, Out, Mat>

where Mat2: Send + 'static,

pub fn interleave_all<Mat2, I>( self, those: I, segment_size: usize, eager_close: bool, ) -> Flow<In, Out, Mat>

where Mat2: Send + 'static, I: IntoIterator<Item = Source<Out, Mat2>>,

pub fn merge_sorted<Mat2>(self, that: Source<Out, Mat2>) -> Flow<In, Out, Mat>

where Out: Ord, Mat2: Send + 'static,

pub fn merge_latest<Mat2>( self, that: Source<Out, Mat2>, eager_complete: bool, ) -> Flow<In, Vec<Out>, Mat>

where Out: Clone, Mat2: Send + 'static,

pub fn merge_all<Mat2, I>( self, those: I, eager_complete: bool, ) -> Flow<In, Out, Mat>

where Mat2: Send + 'static, I: IntoIterator<Item = Source<Out, Mat2>>,

pub fn zip_with<Mat2, Out2, Next, F>( self, that: Source<Out2, Mat2>, combine: F, ) -> Flow<In, Next, Mat>

where Out2: Send + 'static, Next: Send + 'static, Mat2: Send + 'static, F: Fn(Out, Out2) -> Next + Send + Sync + 'static,

pub fn zip_latest<Mat2, Out2>( self, that: Source<Out2, Mat2>, ) -> Flow<In, (Out, Out2), Mat>

where Out: Clone, Out2: Clone + Send + 'static, Mat2: Send + 'static,

pub fn zip_latest_with<Mat2, Out2, Next, F>( self, that: Source<Out2, Mat2>, eager_complete: bool, combine: F, ) -> Flow<In, Next, Mat>

where Out: Clone, Out2: Clone + Send + 'static, Next: Send + 'static, Mat2: Send + 'static, F: Fn(Out, Out2) -> Next + Send + Sync + 'static,

pub fn zip_with_index(self) -> Flow<In, (Out, u64), Mat>

pub fn zip_all<Mat2, Out2>( self, that: Source<Out2, Mat2>, this_elem: Out, that_elem: Out2, ) -> Flow<In, (Out, Out2), Mat>

where Out: Clone + Sync, Out2: Clone + Send + Sync + 'static, Mat2: Send + 'static,

pub fn also_to<SideMat>(self, sink: Sink<Out, SideMat>) -> Flow<In, Out, Mat>

where Out: Clone, SideMat: Send + 'static,

pub fn also_to_all<SideMat, I>(self, sinks: I) -> Flow<In, Out, Mat>

where Out: Clone, SideMat: Send + 'static, I: IntoIterator<Item = Sink<Out, SideMat>>,

pub fn divert_to<SideMat, F>( self, sink: Sink<Out, SideMat>, predicate: F, ) -> Flow<In, Out, Mat>

where SideMat: Send + 'static, F: Fn(&Out) -> bool + Send + Sync + 'static,

pub fn wire_tap<SideMat>(self, sink: Sink<Out, SideMat>) -> Flow<In, Out, Mat>

where Out: Clone, SideMat: Send + 'static,

pub fn intersperse(self, inject: Out) -> Flow<In, Out, Mat>

where Out: Clone + Sync,

pub fn flatten_optional<Inner>(self) -> Flow<In, Inner, Mat>

where Out: Into<Option<Inner>>, Inner: Send + 'static,

pub fn grouped_weighted<F>( self, max_weight: usize, cost_fn: F, ) -> Flow<In, Vec<Out>, Mat>

where F: Fn(&Out) -> usize + Send + Sync + 'static,

pub fn limit_weighted<F>( self, max_weight: usize, cost_fn: F, ) -> Flow<In, Out, Mat>

where F: Fn(&Out) -> usize + Send + Sync + 'static,

pub fn contramap<NewIn, F>(self, f: F) -> Flow<NewIn, Out, Mat>

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

pub fn monitor<F>(self, f: F) -> Flow<In, Out, Mat>

where Out: Clone, F: Fn(&Out) + Send + Sync + 'static,

pub fn watch_termination<CallbackMat, F>( self, materialize_callback: F, ) -> Flow<In, Out, Mat>

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

pub fn to<SinkMat>(self, sink: Sink<Out, SinkMat>) -> Sink<In, Mat>

where SinkMat: Send + 'static,

pub fn to_mat<SinkMat, Combined, F>( self, sink: Sink<Out, SinkMat>, combine: F, ) -> Sink<In, Combined>

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

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

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

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

pub fn buffer( self, size: usize, strategy: OverflowStrategy, ) -> Flow<In, Out, Mat>

pub fn conflate_with_seed<Agg, Seed, Aggregate>( self, seed: Seed, aggregate: Aggregate, ) -> Flow<In, Agg, Mat>

where Agg: Send + 'static, Seed: Fn(Out) -> Agg + Send + Sync + 'static, Aggregate: Fn(Agg, Out) -> Agg + Send + Sync + 'static,

pub fn conflate( self, aggregate: impl Fn(Out, Out) -> Out + Send + Sync + 'static, ) -> Self

pub fn batch<Agg, Seed, Aggregate>( self, max: u64, seed: Seed, aggregate: Aggregate, ) -> Flow<In, Agg, Mat>

where Agg: Send + 'static, Seed: Fn(Out) -> Agg + Send + Sync + 'static, Aggregate: Fn(Agg, Out) -> Agg + Send + Sync + 'static,

pub fn batch_weighted<Agg, Cost, Seed, Aggregate>( self, max: u64, cost_fn: Cost, seed: Seed, aggregate: Aggregate, ) -> Flow<In, Agg, Mat>

where Agg: Send + 'static, Cost: Fn(&Out) -> u64 + Send + Sync + 'static, Seed: Fn(Out) -> Agg + Send + Sync + 'static, Aggregate: Fn(Agg, Out) -> Agg + Send + Sync + 'static,

pub fn expand<Next, Expand, Iter>(self, expand: Expand) -> Flow<In, Next, Mat>

where Next: Send + 'static, Expand: Fn(Out) -> Iter + Send + Sync + 'static, Iter: Iterator<Item = Next> + Send + 'static,

pub fn extrapolate<Expand, Iter>( self, extrapolator: Expand, initial: Option<Out>, ) -> Flow<In, Out, Mat>

where Out: Clone + Sync, Expand: Fn(Out) -> Iter + Send + Sync + 'static, Iter: Iterator<Item = Out> + Send + 'static,

pub fn aggregate_with_boundary<Agg, Emit, Allocate, Aggregate, Harvest>( self, allocate: Allocate, aggregate: Aggregate, harvest: Harvest, emit_on_timer: Option<AggregateTimer<Agg>>, ) -> Flow<In, Emit, Mat>

where Agg: Send + 'static, Emit: Send + 'static, Allocate: Fn() -> Agg + Send + Sync + 'static, Aggregate: Fn(Agg, Out) -> (Agg, bool) + Send + Sync + 'static, Harvest: Fn(Agg) -> Emit + Send + Sync + 'static,

pub fn detach(self) -> Flow<In, Out, Mat>

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

pub fn throttle( self, elements: u64, per: Duration, maximum_burst: i32, mode: ThrottleMode, ) -> Flow<In, Out, Mat>

pub fn throttle_with_cost<CostFn>( self, cost: u64, per: Duration, maximum_burst: i32, cost_fn: CostFn, mode: ThrottleMode, ) -> Flow<In, Out, Mat>

where CostFn: Fn(&Out) -> u64 + Send + Sync + 'static,

pub fn delay( self, delay: Duration, strategy: DelayOverflowStrategy, ) -> Flow<In, Out, Mat>

pub fn delay_with<Supplier, Strategy>( self, delay_strategy_supplier: Supplier, overflow_strategy: DelayOverflowStrategy, ) -> Flow<In, Out, Mat>

where Supplier: Fn() -> Strategy + Send + Sync + 'static, Strategy: FnMut(&Out) -> Duration + Send + 'static,

pub fn initial_delay(self, delay: Duration) -> Flow<In, Out, Mat>

pub fn grouped_within( self, max_number: usize, interval: Duration, ) -> Flow<In, Vec<Out>, Mat>

pub fn grouped_weighted_within<CostFn>( self, max_weight: u64, interval: Duration, cost_fn: CostFn, ) -> Flow<In, Vec<Out>, Mat>

where CostFn: Fn(&Out) -> u64 + Send + Sync + 'static,

pub fn drop_within(self, timeout: Duration) -> Flow<In, Out, Mat>

pub fn take_within(self, timeout: Duration) -> Flow<In, Out, Mat>

pub fn idle_timeout(self, timeout: Duration) -> Flow<In, Out, Mat>

pub fn backpressure_timeout(self, timeout: Duration) -> Flow<In, Out, Mat>

pub fn completion_timeout(self, timeout: Duration) -> Flow<In, Out, Mat>

pub fn initial_timeout(self, timeout: Duration) -> Flow<In, Out, Mat>

pub fn keep_alive<Inject>( self, timeout: Duration, inject: Inject, ) -> Flow<In, Out, Mat>

where Inject: Fn() -> Out + Send + Sync + 'static,

Trait Implementations

impl<In, Out, Mat> Clone for Flow<In, Out, Mat>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.