Trait amadeus::par_sink::Reducer

#[must_use]pub trait Reducer<Source> where
    <Self::Async as ReducerAsync<Source>>::Output == Self::Output, {
    type Output;
    type Async: ReducerAsync<Source>;
    fn into_async(self) -> Self::Async;
}

Associated Types

type Output

type Async: ReducerAsync<Source>

Loading content...

Required methods

fn into_async(self) -> Self::Async

Loading content...

Implementors

impl Reducer<Sum0> for ReduceA0

type Output = ()

type Async = ReduceA0Async

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

impl Reducer<bool> for BoolAndReducer

type Output = bool

type Async = BoolAndReducerAsync

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

impl Reducer<bool> for BoolOrReducer

type Output = bool

type Async = BoolOrReducerAsync

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

impl Reducer<()> for ReduceC0

type Output = ()

type Async = ReduceC0Async

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
    A: Reducer<S0>,
    B: Reducer<S1>,
    C: Reducer<S2>,
    D: Reducer<S3>,
    E: Reducer<S4>,
    F: Reducer<S5>,
    G: Reducer<S6>,
    H: Reducer<S7>, 

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

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>

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
    A: Reducer<S0>,
    B: Reducer<S1>,
    C: Reducer<S2>,
    D: Reducer<S3>,
    E: Reducer<S4>,
    F: Reducer<S5>,
    G: Reducer<S6>,
    H: Reducer<S7>, 

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

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>

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
    A: Reducer<S0>,
    B: Reducer<S1>,
    C: Reducer<S2>,
    D: Reducer<S3>,
    E: Reducer<S4>,
    F: Reducer<S5>,
    G: Reducer<S6>, 

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

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>

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
    A: Reducer<S0>,
    B: Reducer<S1>,
    C: Reducer<S2>,
    D: Reducer<S3>,
    E: Reducer<S4>,
    F: Reducer<S5>,
    G: Reducer<S6>, 

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

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>

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
    A: Reducer<S0>,
    B: Reducer<S1>,
    C: Reducer<S2>,
    D: Reducer<S3>,
    E: Reducer<S4>,
    F: Reducer<S5>, 

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

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>

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
    A: Reducer<S0>,
    B: Reducer<S1>,
    C: Reducer<S2>,
    D: Reducer<S3>,
    E: Reducer<S4>,
    F: Reducer<S5>, 

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

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>

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
    A: Reducer<S0>,
    B: Reducer<S1>,
    C: Reducer<S2>,
    D: Reducer<S3>,
    E: Reducer<S4>, 

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

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>

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
    A: Reducer<S0>,
    B: Reducer<S1>,
    C: Reducer<S2>,
    D: Reducer<S3>,
    E: Reducer<S4>, 

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

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>

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
    A: Reducer<S0>,
    B: Reducer<S1>,
    C: Reducer<S2>,
    D: Reducer<S3>, 

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

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>

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
    A: Reducer<S0>,
    B: Reducer<S1>,
    C: Reducer<S2>,
    D: Reducer<S3>, 

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

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>

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
    A: Reducer<S0>,
    B: Reducer<S1>,
    C: Reducer<S2>, 

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

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

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
    A: Reducer<S0>,
    B: Reducer<S1>,
    C: Reducer<S2>, 

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

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

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 Output = (<A as Reducer<S0>>::Output, <B as Reducer<S1>>::Output)

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

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 Output = (<A as Reducer<S0>>::Output, <B as Reducer<S1>>::Output)

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

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

impl<A, C> Reducer<A> for FolderSyncReducer<A, C> where
    C: FolderSync<A>, 

type Output = <C as FolderSync<A>>::Output

type Async = FolderSyncReducerAsync<A, C, <C as FolderSync<A>>::Output>

fn into_async(self) -> <FolderSyncReducer<A, C> as Reducer<A>>::Async

impl<A, F> Reducer<A> for AllReducer<A, F> where
    F: FnMut(A) -> bool, 

type Output = bool

type Async = AllReducerAsync<A, F>

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

impl<A, F> Reducer<A> for AnyReducer<A, F> where
    F: FnMut(A) -> bool, 

type Output = bool

type Async = AnyReducerAsync<A, F>

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

impl<A, F> Reducer<A> for ForEachReducer<A, F> where
    F: FnMut(A) + Clone, 

type Output = ()

type Async = ForEachReducer<A, F>

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

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

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

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

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

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

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

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

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

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

type Output = T

type Async = PushReducerAsync<A, T>

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

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

type Output = T

type Async = ExtendReducerAsync<A, T>

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

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

type Output = HashMap<T, <R as Reducer<<P as PipeTask<U>>::Item>>::Output, RandomState>

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

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 Output = Result<<R as Reducer<Item>>::Output, E>

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

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 Output = Option<<R as Reducer<Item>>::Output>

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

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>>::Output: Into<T>, 

type Output = T

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

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

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

type Output = HashMap<T, <R as Reducer<U>>::Output, RandomState>

type Async = GroupByReducerBAsync<R, <R as Reducer<U>>::Async, T, U>

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

Loading content...