Trait amadeus::par_sink::ReducerAsync

#[must_use]pub trait ReducerAsync<Source>: Sink<Source> {
    type Output;
    fn output(
        self: Pin<&'a mut Self>
    ) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>>;
}

Associated Types

type Output

Loading content...

Required methods

fn output(
    self: Pin<&'a mut Self>
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>>

Loading content...

Implementations on Foreign Types

impl<P, Source> ReducerAsync<Source> for Pin<P> where
    P: DerefMut + Unpin,
    <P as Deref>::Target: ReducerAsync<Source>, 

type Output = <<P as Deref>::Target as ReducerAsync<Source>>::Output

fn output(
    self: Pin<&'a mut Pin<P>>
) -> Pin<Box<dyn Future<Output = <Pin<P> as ReducerAsync<Source>>::Output> + 'a>>

impl<'_, T, Source> ReducerAsync<Source> for &'_ mut T where
    T: ReducerAsync<Source> + Unpin + ?Sized, 

type Output = <T as ReducerAsync<Source>>::Output

fn output(
    self: Pin<&'a mut &'_ mut T>
) -> Pin<Box<dyn Future<Output = <&'_ mut T as ReducerAsync<Source>>::Output> + 'a>>

Loading content...

Implementors

impl ReducerAsync<Sum0> for ReduceA0Async

type Output = ()

fn output(
    self: Pin<&'a mut ReduceA0Async>
) -> Pin<Box<dyn Future<Output = <ReduceA0Async as ReducerAsync<Sum0>>::Output> + 'a>>

impl ReducerAsync<bool> for BoolAndReducerAsync

type Output = bool

fn output(
    self: Pin<&'a mut BoolAndReducerAsync>
) -> Pin<Box<dyn Future<Output = <BoolAndReducerAsync as ReducerAsync<bool>>::Output> + 'a>>

impl ReducerAsync<bool> for BoolOrReducerAsync

type Output = bool

fn output(
    self: Pin<&'a mut BoolOrReducerAsync>
) -> Pin<Box<dyn Future<Output = <BoolOrReducerAsync as ReducerAsync<bool>>::Output> + 'a>>

impl ReducerAsync<()> for ReduceC0Async

type Output = ()

fn output(
    self: Pin<&'a mut ReduceC0Async>
) -> Pin<Box<dyn Future<Output = <ReduceC0Async as ReducerAsync<()>>::Output> + 'a>>

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

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

fn output(
    self: Pin<&'a mut ReduceA8Async<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7>>
) -> Pin<Box<dyn Future<Output = <ReduceA8Async<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> as ReducerAsync<Sum8<S0, S1, S2, S3, S4, S5, S6, S7>>>::Output> + 'a>>

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

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

fn output(
    self: Pin<&'a mut ReduceC8Async<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7>>
) -> Pin<Box<dyn Future<Output = <ReduceC8Async<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> as ReducerAsync<(S0, S1, S2, S3, S4, S5, S6, S7)>>::Output> + 'a>>

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

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

fn output(
    self: Pin<&'a mut ReduceA7Async<A, B, C, D, E, F, G, S0, S1, S2, S3, S4, S5, S6>>
) -> Pin<Box<dyn Future<Output = <ReduceA7Async<A, B, C, D, E, F, G, S0, S1, S2, S3, S4, S5, S6> as ReducerAsync<Sum7<S0, S1, S2, S3, S4, S5, S6>>>::Output> + 'a>>

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

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

fn output(
    self: Pin<&'a mut ReduceC7Async<A, B, C, D, E, F, G, S0, S1, S2, S3, S4, S5, S6>>
) -> Pin<Box<dyn Future<Output = <ReduceC7Async<A, B, C, D, E, F, G, S0, S1, S2, S3, S4, S5, S6> as ReducerAsync<(S0, S1, S2, S3, S4, S5, S6)>>::Output> + 'a>>

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

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

fn output(
    self: Pin<&'a mut ReduceA6Async<A, B, C, D, E, F, S0, S1, S2, S3, S4, S5>>
) -> Pin<Box<dyn Future<Output = <ReduceA6Async<A, B, C, D, E, F, S0, S1, S2, S3, S4, S5> as ReducerAsync<Sum6<S0, S1, S2, S3, S4, S5>>>::Output> + 'a>>

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

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

fn output(
    self: Pin<&'a mut ReduceC6Async<A, B, C, D, E, F, S0, S1, S2, S3, S4, S5>>
) -> Pin<Box<dyn Future<Output = <ReduceC6Async<A, B, C, D, E, F, S0, S1, S2, S3, S4, S5> as ReducerAsync<(S0, S1, S2, S3, S4, S5)>>::Output> + 'a>>

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

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

fn output(
    self: Pin<&'a mut ReduceA5Async<A, B, C, D, E, S0, S1, S2, S3, S4>>
) -> Pin<Box<dyn Future<Output = <ReduceA5Async<A, B, C, D, E, S0, S1, S2, S3, S4> as ReducerAsync<Sum5<S0, S1, S2, S3, S4>>>::Output> + 'a>>

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

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

fn output(
    self: Pin<&'a mut ReduceC5Async<A, B, C, D, E, S0, S1, S2, S3, S4>>
) -> Pin<Box<dyn Future<Output = <ReduceC5Async<A, B, C, D, E, S0, S1, S2, S3, S4> as ReducerAsync<(S0, S1, S2, S3, S4)>>::Output> + 'a>>

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

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

fn output(
    self: Pin<&'a mut ReduceA4Async<A, B, C, D, S0, S1, S2, S3>>
) -> Pin<Box<dyn Future<Output = <ReduceA4Async<A, B, C, D, S0, S1, S2, S3> as ReducerAsync<Sum4<S0, S1, S2, S3>>>::Output> + 'a>>

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

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

fn output(
    self: Pin<&'a mut ReduceC4Async<A, B, C, D, S0, S1, S2, S3>>
) -> Pin<Box<dyn Future<Output = <ReduceC4Async<A, B, C, D, S0, S1, S2, S3> as ReducerAsync<(S0, S1, S2, S3)>>::Output> + 'a>>

impl<A, B, C, S0, S1, S2> ReducerAsync<Sum3<S0, S1, S2>> for ReduceA3Async<A, B, C, S0, S1, S2> where
    A: ReducerAsync<S0>,
    B: ReducerAsync<S1>,
    C: ReducerAsync<S2>, 

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

fn output(
    self: Pin<&'a mut ReduceA3Async<A, B, C, S0, S1, S2>>
) -> Pin<Box<dyn Future<Output = <ReduceA3Async<A, B, C, S0, S1, S2> as ReducerAsync<Sum3<S0, S1, S2>>>::Output> + 'a>>

impl<A, B, C, S0, S1, S2> ReducerAsync<(S0, S1, S2)> for ReduceC3Async<A, B, C, S0, S1, S2> where
    A: ReducerAsync<S0>,
    B: ReducerAsync<S1>,
    C: ReducerAsync<S2>, 

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

fn output(
    self: Pin<&'a mut ReduceC3Async<A, B, C, S0, S1, S2>>
) -> Pin<Box<dyn Future<Output = <ReduceC3Async<A, B, C, S0, S1, S2> as ReducerAsync<(S0, S1, S2)>>::Output> + 'a>>

impl<A, B, S0, S1> ReducerAsync<Sum2<S0, S1>> for ReduceA2Async<A, B, S0, S1> where
    A: ReducerAsync<S0>,
    B: ReducerAsync<S1>, 

type Output = (<A as ReducerAsync<S0>>::Output, <B as ReducerAsync<S1>>::Output)

fn output(
    self: Pin<&'a mut ReduceA2Async<A, B, S0, S1>>
) -> Pin<Box<dyn Future<Output = <ReduceA2Async<A, B, S0, S1> as ReducerAsync<Sum2<S0, S1>>>::Output> + 'a>>

impl<A, B, S0, S1> ReducerAsync<(S0, S1)> for ReduceC2Async<A, B, S0, S1> where
    A: ReducerAsync<S0>,
    B: ReducerAsync<S1>, 

type Output = (<A as ReducerAsync<S0>>::Output, <B as ReducerAsync<S1>>::Output)

fn output(
    self: Pin<&'a mut ReduceC2Async<A, B, S0, S1>>
) -> Pin<Box<dyn Future<Output = <ReduceC2Async<A, B, S0, S1> as ReducerAsync<(S0, S1)>>::Output> + 'a>>

impl<A, C> ReducerAsync<A> for FolderSyncReducerAsync<A, C, <C as FolderSync<A>>::Output> where
    C: FolderSync<A>, 

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

fn output(
    self: Pin<&'a mut FolderSyncReducerAsync<A, C, <C as FolderSync<A>>::Output>>
) -> Pin<Box<dyn Future<Output = <FolderSyncReducerAsync<A, C, <C as FolderSync<A>>::Output> as ReducerAsync<A>>::Output> + 'a>>

impl<A, F> ReducerAsync<A> for AllReducerAsync<A, F> where
    F: FnMut<(A,), Output = bool>, 

type Output = bool

fn output(
    self: Pin<&'a mut AllReducerAsync<A, F>>
) -> Pin<Box<dyn Future<Output = <AllReducerAsync<A, F> as ReducerAsync<A>>::Output> + 'a>>

impl<A, F> ReducerAsync<A> for AnyReducerAsync<A, F> where
    F: FnMut<(A,), Output = bool>, 

type Output = bool

fn output(
    self: Pin<&'a mut AnyReducerAsync<A, F>>
) -> Pin<Box<dyn Future<Output = <AnyReducerAsync<A, F> as ReducerAsync<A>>::Output> + 'a>>

impl<A, F> ReducerAsync<A> for ForEachReducer<A, F> where
    F: FnMut<(A,), Output = ()> + Clone, 

type Output = ()

fn output(
    self: Pin<&'a mut ForEachReducer<A, F>>
) -> Pin<Box<dyn Future<Output = <ForEachReducer<A, F> as ReducerAsync<A>>::Output> + 'a>>

impl<A, S0> ReducerAsync<Sum1<S0>> for ReduceA1Async<A, S0> where
    A: ReducerAsync<S0>, 

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

fn output(
    self: Pin<&'a mut ReduceA1Async<A, S0>>
) -> Pin<Box<dyn Future<Output = <ReduceA1Async<A, S0> as ReducerAsync<Sum1<S0>>>::Output> + 'a>>

impl<A, S0> ReducerAsync<(S0,)> for ReduceC1Async<A, S0> where
    A: ReducerAsync<S0>, 

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

fn output(
    self: Pin<&'a mut ReduceC1Async<A, S0>>
) -> Pin<Box<dyn Future<Output = <ReduceC1Async<A, S0> as ReducerAsync<(S0,)>>::Output> + 'a>>

impl<A, T> ReducerAsync<A> for PushReducerAsync<A, T> where
    T: Extend<A>, 

type Output = T

fn output(
    self: Pin<&'a mut PushReducerAsync<A, T>>
) -> Pin<Box<dyn Future<Output = <PushReducerAsync<A, T> as ReducerAsync<A>>::Output> + 'a>>

impl<A, T, B> ReducerAsync<A> for ExtendReducerAsync<A, T> where
    A: IntoIterator<Item = B>,
    T: Extend<B>, 

type Output = T

fn output(
    self: Pin<&'a mut ExtendReducerAsync<A, T>>
) -> Pin<Box<dyn Future<Output = <ExtendReducerAsync<A, T> as ReducerAsync<A>>::Output> + 'a>>

impl<P, R, T, U> ReducerAsync<(T, U)> for GroupByReducerAAsync<P, R, <R as Reducer<<P as Pipe<U>>::Item>>::Async, T, U> where
    P: Pipe<U>,
    R: Reducer<<P as Pipe<U>>::Item> + Clone,
    T: Eq + Hash, 

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

fn output(
    self: Pin<&'a mut GroupByReducerAAsync<P, R, <R as Reducer<<P as Pipe<U>>::Item>>::Async, T, U>>
) -> Pin<Box<dyn Future<Output = <GroupByReducerAAsync<P, R, <R as Reducer<<P as Pipe<U>>::Item>>::Async, T, U> as ReducerAsync<(T, U)>>::Output> + 'a>>

impl<R, E, Item> ReducerAsync<Result<Item, E>> for ResultReducerAsync<R, E> where
    R: ReducerAsync<Item>, 

type Output = Result<<R as ReducerAsync<Item>>::Output, E>

fn output(
    self: Pin<&'a mut ResultReducerAsync<R, E>>
) -> Pin<Box<dyn Future<Output = <ResultReducerAsync<R, E> as ReducerAsync<Result<Item, E>>>::Output> + 'a>>

impl<R, Item> ReducerAsync<Option<Item>> for OptionReducerAsync<R> where
    R: ReducerAsync<Item>, 

type Output = Option<<R as ReducerAsync<Item>>::Output>

fn output(
    self: Pin<&'a mut OptionReducerAsync<R>>
) -> Pin<Box<dyn Future<Output = <OptionReducerAsync<R> as ReducerAsync<Option<Item>>>::Output> + 'a>>

impl<R, T, Item> ReducerAsync<Item> for IntoReducerAsync<R, T> where
    R: ReducerAsync<Item>,
    <R as ReducerAsync<Item>>::Output: Into<T>, 

type Output = T

fn output(
    self: Pin<&'a mut IntoReducerAsync<R, T>>
) -> Pin<Box<dyn Future<Output = <IntoReducerAsync<R, T> as ReducerAsync<Item>>::Output> + 'a>>

impl<R, T, U> ReducerAsync<HashMap<T, U, RandomState>> for GroupByReducerBAsync<R, <R as Reducer<U>>::Async, T, U> where
    R: Reducer<U> + Clone,
    T: Eq + Hash, 

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

fn output(
    self: Pin<&'a mut GroupByReducerBAsync<R, <R as Reducer<U>>::Async, T, U>>
) -> Pin<Box<dyn Future<Output = <GroupByReducerBAsync<R, <R as Reducer<U>>::Async, T, U> as ReducerAsync<HashMap<T, U, RandomState>>>::Output> + 'a>>

Loading content...