Trait amadeus::par_sink::Reducer

#[must_use]
pub trait Reducer<Item> {
    type Done;
    type Async: Sink<Item>;
    fn into_async(self) -> Self::Async;
}

Associated Types

type Done

type Async: Sink<Item>

Required methods

fn into_async(self) -> Self::Async

Implementors

impl Reducer<Sum0> for ReduceA0

type Done = ()

type Async = ReduceA0Async

pub fn into_async(self) -> <ReduceA0 as Reducer<Sum0>>::Async

impl Reducer<bool> for BoolAndReducer

type Done = bool

type Async = BoolAndReducerAsync

pub fn into_async(self) -> <BoolAndReducer as Reducer<bool>>::Async

impl Reducer<bool> for BoolOrReducer

type Done = bool

type Async = BoolOrReducerAsync

pub fn into_async(self) -> <BoolOrReducer as Reducer<bool>>::Async

impl Reducer<()> for ReduceC0

type Done = ()

type Async = ReduceC0Async

pub fn into_async(self) -> <ReduceC0 as Reducer<()>>::Async

impl<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> Reducer<Sum8<S0, S1, S2, S3, S4, S5, S6, S7>> for ReduceA8<A, B, C, D, E, F, G, H> where
    C: Reducer<S2>,
    D: Reducer<S3>,
    H: Reducer<S7>,
    F: Reducer<S5>,
    E: Reducer<S4>,
    A: Reducer<S0>,
    B: Reducer<S1>,
    G: Reducer<S6>, 

type Done = (<A as Reducer<S0>>::Done, <B as Reducer<S1>>::Done, <C as Reducer<S2>>::Done, <D as Reducer<S3>>::Done, <E as Reducer<S4>>::Done, <F as Reducer<S5>>::Done, <G as Reducer<S6>>::Done, <H as Reducer<S7>>::Done)

type Async = ReduceA8Async<<A as Reducer<S0>>::Async, <B as Reducer<S1>>::Async, <C as Reducer<S2>>::Async, <D as Reducer<S3>>::Async, <E as Reducer<S4>>::Async, <F as Reducer<S5>>::Async, <G as Reducer<S6>>::Async, <H as Reducer<S7>>::Async, S0, S1, S2, S3, S4, S5, S6, S7>

pub fn into_async(
    self
) -> <ReduceA8<A, B, C, D, E, F, G, H> as Reducer<Sum8<S0, S1, S2, S3, S4, S5, S6, S7>>>::Async

impl<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> Reducer<(S0, S1, S2, S3, S4, S5, S6, S7)> for ReduceC8<A, B, C, D, E, F, G, H> where
    C: Reducer<S2>,
    D: Reducer<S3>,
    H: Reducer<S7>,
    F: Reducer<S5>,
    E: Reducer<S4>,
    A: Reducer<S0>,
    B: Reducer<S1>,
    G: Reducer<S6>, 

type Done = (<A as Reducer<S0>>::Done, <B as Reducer<S1>>::Done, <C as Reducer<S2>>::Done, <D as Reducer<S3>>::Done, <E as Reducer<S4>>::Done, <F as Reducer<S5>>::Done, <G as Reducer<S6>>::Done, <H as Reducer<S7>>::Done)

type Async = ReduceC8Async<<A as Reducer<S0>>::Async, <B as Reducer<S1>>::Async, <C as Reducer<S2>>::Async, <D as Reducer<S3>>::Async, <E as Reducer<S4>>::Async, <F as Reducer<S5>>::Async, <G as Reducer<S6>>::Async, <H as Reducer<S7>>::Async, S0, S1, S2, S3, S4, S5, S6, S7>

pub fn into_async(
    self
) -> <ReduceC8<A, B, C, D, E, F, G, H> as Reducer<(S0, S1, S2, S3, S4, S5, S6, S7)>>::Async

impl<A, B, C, D, E, F, G, S0, S1, S2, S3, S4, S5, S6> Reducer<Sum7<S0, S1, S2, S3, S4, S5, S6>> for ReduceA7<A, B, C, D, E, F, G> where
    C: Reducer<S2>,
    D: Reducer<S3>,
    F: Reducer<S5>,
    E: Reducer<S4>,
    A: Reducer<S0>,
    B: Reducer<S1>,
    G: Reducer<S6>, 

type Done = (<A as Reducer<S0>>::Done, <B as Reducer<S1>>::Done, <C as Reducer<S2>>::Done, <D as Reducer<S3>>::Done, <E as Reducer<S4>>::Done, <F as Reducer<S5>>::Done, <G as Reducer<S6>>::Done)

type Async = ReduceA7Async<<A as Reducer<S0>>::Async, <B as Reducer<S1>>::Async, <C as Reducer<S2>>::Async, <D as Reducer<S3>>::Async, <E as Reducer<S4>>::Async, <F as Reducer<S5>>::Async, <G as Reducer<S6>>::Async, S0, S1, S2, S3, S4, S5, S6>

pub fn into_async(
    self
) -> <ReduceA7<A, B, C, D, E, F, G> as Reducer<Sum7<S0, S1, S2, S3, S4, S5, S6>>>::Async

impl<A, B, C, D, E, F, G, S0, S1, S2, S3, S4, S5, S6> Reducer<(S0, S1, S2, S3, S4, S5, S6)> for ReduceC7<A, B, C, D, E, F, G> where
    C: Reducer<S2>,
    D: Reducer<S3>,
    F: Reducer<S5>,
    E: Reducer<S4>,
    A: Reducer<S0>,
    B: Reducer<S1>,
    G: Reducer<S6>, 

type Done = (<A as Reducer<S0>>::Done, <B as Reducer<S1>>::Done, <C as Reducer<S2>>::Done, <D as Reducer<S3>>::Done, <E as Reducer<S4>>::Done, <F as Reducer<S5>>::Done, <G as Reducer<S6>>::Done)

type Async = ReduceC7Async<<A as Reducer<S0>>::Async, <B as Reducer<S1>>::Async, <C as Reducer<S2>>::Async, <D as Reducer<S3>>::Async, <E as Reducer<S4>>::Async, <F as Reducer<S5>>::Async, <G as Reducer<S6>>::Async, S0, S1, S2, S3, S4, S5, S6>

pub fn into_async(
    self
) -> <ReduceC7<A, B, C, D, E, F, G> as Reducer<(S0, S1, S2, S3, S4, S5, S6)>>::Async

impl<A, B, C, D, E, F, S0, S1, S2, S3, S4, S5> Reducer<Sum6<S0, S1, S2, S3, S4, S5>> for ReduceA6<A, B, C, D, E, F> where
    C: Reducer<S2>,
    D: Reducer<S3>,
    F: Reducer<S5>,
    E: Reducer<S4>,
    A: Reducer<S0>,
    B: Reducer<S1>, 

type Done = (<A as Reducer<S0>>::Done, <B as Reducer<S1>>::Done, <C as Reducer<S2>>::Done, <D as Reducer<S3>>::Done, <E as Reducer<S4>>::Done, <F as Reducer<S5>>::Done)

type Async = ReduceA6Async<<A as Reducer<S0>>::Async, <B as Reducer<S1>>::Async, <C as Reducer<S2>>::Async, <D as Reducer<S3>>::Async, <E as Reducer<S4>>::Async, <F as Reducer<S5>>::Async, S0, S1, S2, S3, S4, S5>

pub fn into_async(
    self
) -> <ReduceA6<A, B, C, D, E, F> as Reducer<Sum6<S0, S1, S2, S3, S4, S5>>>::Async

impl<A, B, C, D, E, F, S0, S1, S2, S3, S4, S5> Reducer<(S0, S1, S2, S3, S4, S5)> for ReduceC6<A, B, C, D, E, F> where
    C: Reducer<S2>,
    D: Reducer<S3>,
    F: Reducer<S5>,
    E: Reducer<S4>,
    A: Reducer<S0>,
    B: Reducer<S1>, 

type Done = (<A as Reducer<S0>>::Done, <B as Reducer<S1>>::Done, <C as Reducer<S2>>::Done, <D as Reducer<S3>>::Done, <E as Reducer<S4>>::Done, <F as Reducer<S5>>::Done)

type Async = ReduceC6Async<<A as Reducer<S0>>::Async, <B as Reducer<S1>>::Async, <C as Reducer<S2>>::Async, <D as Reducer<S3>>::Async, <E as Reducer<S4>>::Async, <F as Reducer<S5>>::Async, S0, S1, S2, S3, S4, S5>

pub fn into_async(
    self
) -> <ReduceC6<A, B, C, D, E, F> as Reducer<(S0, S1, S2, S3, S4, S5)>>::Async

impl<A, B, C, D, E, S0, S1, S2, S3, S4> Reducer<Sum5<S0, S1, S2, S3, S4>> for ReduceA5<A, B, C, D, E> where
    C: Reducer<S2>,
    D: Reducer<S3>,
    E: Reducer<S4>,
    A: Reducer<S0>,
    B: Reducer<S1>, 

type Done = (<A as Reducer<S0>>::Done, <B as Reducer<S1>>::Done, <C as Reducer<S2>>::Done, <D as Reducer<S3>>::Done, <E as Reducer<S4>>::Done)

type Async = ReduceA5Async<<A as Reducer<S0>>::Async, <B as Reducer<S1>>::Async, <C as Reducer<S2>>::Async, <D as Reducer<S3>>::Async, <E as Reducer<S4>>::Async, S0, S1, S2, S3, S4>

pub fn into_async(
    self
) -> <ReduceA5<A, B, C, D, E> as Reducer<Sum5<S0, S1, S2, S3, S4>>>::Async

impl<A, B, C, D, E, S0, S1, S2, S3, S4> Reducer<(S0, S1, S2, S3, S4)> for ReduceC5<A, B, C, D, E> where
    C: Reducer<S2>,
    D: Reducer<S3>,
    E: Reducer<S4>,
    A: Reducer<S0>,
    B: Reducer<S1>, 

type Done = (<A as Reducer<S0>>::Done, <B as Reducer<S1>>::Done, <C as Reducer<S2>>::Done, <D as Reducer<S3>>::Done, <E as Reducer<S4>>::Done)

type Async = ReduceC5Async<<A as Reducer<S0>>::Async, <B as Reducer<S1>>::Async, <C as Reducer<S2>>::Async, <D as Reducer<S3>>::Async, <E as Reducer<S4>>::Async, S0, S1, S2, S3, S4>

pub fn into_async(
    self
) -> <ReduceC5<A, B, C, D, E> as Reducer<(S0, S1, S2, S3, S4)>>::Async

impl<A, B, C, D, S0, S1, S2, S3> Reducer<Sum4<S0, S1, S2, S3>> for ReduceA4<A, B, C, D> where
    C: Reducer<S2>,
    D: Reducer<S3>,
    A: Reducer<S0>,
    B: Reducer<S1>, 

type Done = (<A as Reducer<S0>>::Done, <B as Reducer<S1>>::Done, <C as Reducer<S2>>::Done, <D as Reducer<S3>>::Done)

type Async = ReduceA4Async<<A as Reducer<S0>>::Async, <B as Reducer<S1>>::Async, <C as Reducer<S2>>::Async, <D as Reducer<S3>>::Async, S0, S1, S2, S3>

pub fn into_async(
    self
) -> <ReduceA4<A, B, C, D> as Reducer<Sum4<S0, S1, S2, S3>>>::Async

impl<A, B, C, D, S0, S1, S2, S3> Reducer<(S0, S1, S2, S3)> for ReduceC4<A, B, C, D> where
    C: Reducer<S2>,
    D: Reducer<S3>,
    A: Reducer<S0>,
    B: Reducer<S1>, 

type Done = (<A as Reducer<S0>>::Done, <B as Reducer<S1>>::Done, <C as Reducer<S2>>::Done, <D as Reducer<S3>>::Done)

type Async = ReduceC4Async<<A as Reducer<S0>>::Async, <B as Reducer<S1>>::Async, <C as Reducer<S2>>::Async, <D as Reducer<S3>>::Async, S0, S1, S2, S3>

pub fn into_async(
    self
) -> <ReduceC4<A, B, C, D> as Reducer<(S0, S1, S2, S3)>>::Async

impl<A, B, C, S0, S1, S2> Reducer<Sum3<S0, S1, S2>> for ReduceA3<A, B, C> where
    C: Reducer<S2>,
    A: Reducer<S0>,
    B: Reducer<S1>, 

type Done = (<A as Reducer<S0>>::Done, <B as Reducer<S1>>::Done, <C as Reducer<S2>>::Done)

type Async = ReduceA3Async<<A as Reducer<S0>>::Async, <B as Reducer<S1>>::Async, <C as Reducer<S2>>::Async, S0, S1, S2>

pub fn into_async(
    self
) -> <ReduceA3<A, B, C> as Reducer<Sum3<S0, S1, S2>>>::Async

impl<A, B, C, S0, S1, S2> Reducer<(S0, S1, S2)> for ReduceC3<A, B, C> where
    C: Reducer<S2>,
    A: Reducer<S0>,
    B: Reducer<S1>, 

type Done = (<A as Reducer<S0>>::Done, <B as Reducer<S1>>::Done, <C as Reducer<S2>>::Done)

type Async = ReduceC3Async<<A as Reducer<S0>>::Async, <B as Reducer<S1>>::Async, <C as Reducer<S2>>::Async, S0, S1, S2>

pub fn into_async(self) -> <ReduceC3<A, B, C> as Reducer<(S0, S1, S2)>>::Async

impl<A, B, S0, S1> Reducer<Sum2<S0, S1>> for ReduceA2<A, B> where
    A: Reducer<S0>,
    B: Reducer<S1>, 

type Done = (<A as Reducer<S0>>::Done, <B as Reducer<S1>>::Done)

type Async = ReduceA2Async<<A as Reducer<S0>>::Async, <B as Reducer<S1>>::Async, S0, S1>

pub fn into_async(self) -> <ReduceA2<A, B> as Reducer<Sum2<S0, S1>>>::Async

impl<A, B, S0, S1> Reducer<(S0, S1)> for ReduceC2<A, B> where
    A: Reducer<S0>,
    B: Reducer<S1>, 

type Done = (<A as Reducer<S0>>::Done, <B as Reducer<S1>>::Done)

type Async = ReduceC2Async<<A as Reducer<S0>>::Async, <B as Reducer<S1>>::Async, S0, S1>

pub fn into_async(self) -> <ReduceC2<A, B> as Reducer<(S0, S1)>>::Async

impl<A, S0> Reducer<Sum1<S0>> for ReduceA1<A> where
    A: Reducer<S0>, 

type Done = (<A as Reducer<S0>>::Done,)

type Async = ReduceA1Async<<A as Reducer<S0>>::Async, S0>

pub fn into_async(self) -> <ReduceA1<A> as Reducer<Sum1<S0>>>::Async

impl<A, S0> Reducer<(S0,)> for ReduceC1<A> where
    A: Reducer<S0>, 

type Done = (<A as Reducer<S0>>::Done,)

type Async = ReduceC1Async<<A as Reducer<S0>>::Async, S0>

pub fn into_async(self) -> <ReduceC1<A> as Reducer<(S0,)>>::Async

impl<Item, F> Reducer<Item> for AllReducer<Item, F> where
    F: FnMut<(Item,), Output = bool>, 

type Done = bool

type Async = AllReducerAsync<Item, F>

pub fn into_async(self) -> <AllReducer<Item, F> as Reducer<Item>>::Async

impl<Item, F> Reducer<Item> for AnyReducer<Item, F> where
    F: FnMut<(Item,), Output = bool>, 

type Done = bool

type Async = AnyReducerAsync<Item, F>

pub fn into_async(self) -> <AnyReducer<Item, F> as Reducer<Item>>::Async

impl<Item, F> Reducer<Item> for FolderSyncReducer<Item, F, Final> where
    F: FolderSync<Item>, 

type Done = <F as FolderSync<Item>>::Done

type Async = FolderSyncReducerAsync<Item, F, <F as FolderSync<Item>>::State, Final>

pub fn into_async(
    self
) -> <FolderSyncReducer<Item, F, Final> as Reducer<Item>>::Async

impl<Item, F> Reducer<Item> for FolderSyncReducer<Item, F, Inter> where
    F: FolderSync<Item>, 

type Done = <F as FolderSync<Item>>::State

type Async = FolderSyncReducerAsync<Item, F, <F as FolderSync<Item>>::State, Inter>

pub fn into_async(
    self
) -> <FolderSyncReducer<Item, F, Inter> as Reducer<Item>>::Async

impl<Item, F> Reducer<Item> for ForEachReducer<Item, F> where
    F: FnMut<(Item,), Output = ()>, 

type Done = ()

type Async = ForEachReducer<Item, F>

pub fn into_async(self) -> <ForEachReducer<Item, F> as Reducer<Item>>::Async

impl<Item, T> Reducer<Item> for PushReducer<Item, T> where
    T: Default + Extend<Item>, 

type Done = T

type Async = PushReducerAsync<Item, T>

pub fn into_async(self) -> <PushReducer<Item, T> as Reducer<Item>>::Async

impl<Item, T, B> Reducer<Item> for ExtendReducer<Item, T> where
    T: Default + Extend<B>,
    Item: IntoIterator<Item = B>, 

type Done = T

type Async = ExtendReducerAsync<Item, T>

pub fn into_async(self) -> <ExtendReducer<Item, T> as Reducer<Item>>::Async

impl<P, R, T, U> Reducer<(T, U)> for GroupByReducerA<P, R, T, U> where
    T: Eq + Hash,
    P: PipeTask<U>,
    R: Reducer<<P as PipeTask<U>>::Output> + Clone, 

type Done = IndexMap<T, <R as Reducer<<P as PipeTask<U>>::Output>>::Done, RandomState>

type Async = GroupByReducerAAsync<<P as PipeTask<U>>::Async, R, T, U>

pub fn into_async(
    self
) -> <GroupByReducerA<P, R, T, U> as Reducer<(T, U)>>::Async

impl<R, E, Item> Reducer<Result<Item, E>> for ResultReducer<R, E> where
    R: Reducer<Item>, 

type Done = Result<<R as Reducer<Item>>::Done, E>

type Async = ResultReducerAsync<<R as Reducer<Item>>::Async, E>

pub fn into_async(
    self
) -> <ResultReducer<R, E> as Reducer<Result<Item, E>>>::Async

impl<R, Item> Reducer<Option<Item>> for OptionReducer<R> where
    R: Reducer<Item>, 

type Done = Option<<R as Reducer<Item>>::Done>

type Async = OptionReducerAsync<<R as Reducer<Item>>::Async>

pub fn into_async(self) -> <OptionReducer<R> as Reducer<Option<Item>>>::Async

impl<R, T, Item> Reducer<Item> for IntoReducer<R, T> where
    R: Reducer<Item>,
    <R as Reducer<Item>>::Done: Into<T>, 

type Done = T

type Async = IntoReducerAsync<<R as Reducer<Item>>::Async, T>

pub fn into_async(self) -> <IntoReducer<R, T> as Reducer<Item>>::Async

impl<R, T, U> Reducer<IndexMap<T, U, RandomState>> for GroupByReducerB<R, T, U> where
    T: Eq + Hash,
    R: Reducer<U> + Clone, 

type Done = IndexMap<T, <R as Reducer<U>>::Done, RandomState>

type Async = GroupByReducerBAsync<R, T, U>

pub fn into_async(
    self
) -> <GroupByReducerB<R, T, U> as Reducer<IndexMap<T, U, RandomState>>>::Async