Struct Funnel 

pub struct Funnel<C, T, F> { /* private fields */ }

A RefCollector that maps a mutable reference to an item into another mutable reference.

This struct is created by RefCollector::funnel(). See its documentation for more.

Trait Implementations

impl<C: Clone, T, F: Clone> Clone for Funnel<C, T, F>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, C, F> Collector for Funnel<C, T, F>

where C: RefCollector, F: FnMut(&mut T) -> &mut C::Item,

type Item = T

Type of items this collector collects and accumulates.

type Output = <C as Collector>::Output

The result this collector yields, via the finish method.

fn collect(&mut self, item: Self::Item) -> ControlFlow<()>

Collects an item and returns a ControlFlow indicating whether the collector has stopped accumulating right after this operation.

fn finish(self) -> Self::Output

Consumes the collector and returns the accumulated result.

fn break_hint(&self) -> bool

Returns a hint whether the collector has stopped accumulating.

fn collect_many( &mut self, items: impl IntoIterator<Item = Self::Item>, ) -> ControlFlow<()>

where Self: Sized,

Collects items from an iterator and returns a ControlFlow indicating whether the collector has stopped collecting right after this operation.

fn collect_then_finish( self, items: impl IntoIterator<Item = Self::Item>, ) -> Self::Output

where Self: Sized,

Collects items from an iterator, consumes the collector, and produces the accumulated result.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Creates a Collector that can “safely” collect items even after the underlying collector has stopped accumulating, without triggering undesired behaviors.

fn cloned(self) -> Cloning<Self>

where Self: Sized, Self::Item: Clone,

👎Deprecated since 0.3.0: Use cloning()

Use cloning().

fn cloning(self) -> Cloning<Self>

where Self: Sized, Self::Item: Clone,

Creates a RefCollector that clones every collected item.

fn copied(self) -> Copying<Self>

where Self: Sized, Self::Item: Copy,

👎Deprecated since 0.3.0: Use copying()

Use copying().

fn copying(self) -> Copying<Self>

where Self: Sized, Self::Item: Copy,

Creates a RefCollector that copies every collected item.

fn map<F, T>(self, f: F) -> Map<Self, T, F>

where Self: Sized, F: FnMut(T) -> Self::Item,

Creates a Collector that calls a closure on each item before collecting.

fn map_ref<F, T>(self, f: F) -> MapRef<Self, T, F>

where Self: Sized, F: FnMut(&mut T) -> Self::Item,

Creates a RefCollector that calls a closure on each item by mutable reference before collecting.

fn filter<F>(self, pred: F) -> Filter<Self, F>

where Self: Sized, F: FnMut(&Self::Item) -> bool,

Creates a Collector that uses a closure to determine whether an item should be accumulated.

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

where Self: Sized,

Creates a Collector that stops accumulating after collecting the first n items, or fewer if the underlying collector ends sooner.

fn take_while<F>(self, pred: F) -> TakeWhile<Self, F>

where Self: Sized, F: FnMut(&Self::Item) -> bool,

Creates a Collector that accumulates items as long as a predicate returns true.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates a Collector that skips the first n collected items before it begins accumulating them.

fn chain<C>(self, other: C) -> Chain<Self, C::IntoCollector>

where Self: Sized, C: IntoCollector<Item = Self::Item>,

Creates a Collector that feeds every item in the first collector until it stops accumulating, then continues feeding items into the second one.

fn partition<C, F>( self, pred: F, other_if_false: C, ) -> Partition<Self, C::IntoCollector, F>

where Self: Sized, C: IntoCollector<Item = Self::Item>, F: FnMut(&mut Self::Item) -> bool,

Creates a Collector that distributes items between two collectors based on a predicate.

fn unzip<C>(self, other: C) -> Unzip<Self, C::IntoCollector>

where Self: Sized, C: IntoCollector,

Creates a Collector that destructures each 2-tuple (A, B) item and distributes its fields: A goes to the first collector, and B goes to the second collector.

fn unbatching<T, F>(self, f: F) -> Unbatching<Self, T, F>

where Self: Sized, F: FnMut(&mut Self, T) -> ControlFlow<()>,

Creates a Collector with a custom collection logic.

fn unbatching_ref<T, F>(self, f: F) -> UnbatchingRef<Self, T, F>

where Self: Sized, F: FnMut(&mut Self, &mut T) -> ControlFlow<()>,

Creates a RefCollector with a custom collection logic.

fn map_output<T, F>(self, f: F) -> MapOutput<Self, T, F>

where Self: Sized, F: FnOnce(Self::Output) -> T,

Creates a Collector that transforms the final accumulated result.

fn nest<C>(self, inner: C) -> Nest<Self, C::IntoCollector>

where Self: Collector<Item = C::Output> + Sized, C: IntoCollector<IntoCollector: Clone>,

Available on crate feature unstable only.

Creates a Collector that collects all outputs produced by an inner collector.

fn nest_exact<C>(self, inner: C) -> NestExact<Self, C::IntoCollector>

where Self: Collector<Item = C::Output> + Sized, C: IntoCollector<IntoCollector: Clone>,

Available on crate feature unstable only.

Creates a Collector that collects all outputs produced by an inner collector.

impl<C: Debug, T, F> Debug for Funnel<C, T, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, C, F> RefCollector for Funnel<C, T, F>

where C: RefCollector, F: FnMut(&mut T) -> &mut C::Item,

fn collect_ref(&mut self, item: &mut T) -> ControlFlow<()>

Collects an item and returns a ControlFlow indicating whether the collector has stopped accumulating right after this operation.

fn then<C>(self, other: C) -> Combine<Self, C::IntoCollector>

where Self: Sized, C: IntoCollector<Item = Self::Item>,

👎Deprecated since 0.3.0: Use combine()

Use combine().

fn combine<C>(self, other: C) -> Combine<Self, C::IntoCollector>

where Self: Sized, C: IntoCollector<Item = Self::Item>,

The most important adaptor. The reason why this crate exists.

fn funnel<F, T>(self, func: F) -> Funnel<Self, T, F>

where Self: Sized, F: FnMut(&mut T) -> &mut Self::Item,

Creates a RefCollector that maps a mutable reference to an item into another mutable reference.