Trait amadeus_core::par_sink::ReducerAsync

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

Associated Types

type Output

Loading content...

Required methods

fn output<'a>(
    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::Target: ReducerAsync<Source>, 

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

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

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

type Output = T::Output

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

Loading content...

Implementors

impl ReducerAsync<Sum0> for ReduceA0Async

type Output = ()

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

impl ReducerAsync<bool> for BoolAndReducerAsync

type Output = bool

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

impl ReducerAsync<bool> for BoolOrReducerAsync

type Output = bool

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

impl ReducerAsync<()> for ReduceC0Async

type Output = ()

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

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

type Output = C::Output

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

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

type Output = bool

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

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

type Output = bool

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

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

type Output = ()

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

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

type Output = T

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

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

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output)

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

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

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output)

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

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

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output)

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

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

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output)

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

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

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output)

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

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

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output)

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

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

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output)

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

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

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output)

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

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

type Output = (A::Output, B::Output, C::Output, D::Output)

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

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

type Output = (A::Output, B::Output, C::Output, D::Output)

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

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

type Output = (A::Output, B::Output, C::Output)

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

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

type Output = (A::Output, B::Output, C::Output)

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

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

type Output = (A::Output, B::Output)

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

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

type Output = (A::Output, B::Output)

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

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

type Output = (A::Output,)

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

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

type Output = (A::Output,)

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

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

type Output = T

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

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

type Output = HashMap<T, R::Output>

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

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

type Output = HashMap<T, R::Output>

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

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

type Output = Result<R::Output, E>

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

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

type Output = Option<R::Output>

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

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

type Output = T

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

Loading content...