Trait amadeus_core::par_sink::Reducer

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

Associated Types

type Item

type Output

type Async: ReducerAsync<Item = Self::Item, Output = Self::Output>

Loading content...

Required methods

fn into_async(self) -> Self::Async

Loading content...

Implementors

impl Reducer for BoolAndReducer

type Item = bool

type Output = bool

type Async = Self

fn into_async(self) -> Self::Async

impl Reducer for BoolOrReducer

type Item = bool

type Output = bool

type Async = Self

fn into_async(self) -> Self::Async

impl Reducer for ReduceA0

type Item = Sum0

type Output = ()

type Async = ReduceA0Async

fn into_async(self) -> Self::Async

impl Reducer for ReduceC0

type Item = ()

type Output = ()

type Async = ReduceC0Async

fn into_async(self) -> Self::Async

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

type Item = A

type Output = C::Output

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

fn into_async(self) -> Self::Async

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

type Item = A

type Output = bool

type Async = Self

fn into_async(self) -> Self::Async

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

type Item = A

type Output = bool

type Async = Self

fn into_async(self) -> Self::Async

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

type Item = A

type Output = ()

type Async = Self

fn into_async(self) -> Self::Async

impl<A, T: Extend<A>> Reducer for PushReducer<A, T>

type Item = A

type Output = T

type Async = Self

fn into_async(self) -> Self::Async

impl<A: Reducer> Reducer for ReduceA1<A>

type Item = Sum1<A::Item>

type Output = (A::Output,)

type Async = ReduceA1Async<A::Async>

fn into_async(self) -> Self::Async

impl<A: Reducer> Reducer for ReduceC1<A>

type Item = (A::Item,)

type Output = (A::Output,)

type Async = ReduceC1Async<A::Async>

fn into_async(self) -> Self::Async

impl<A: Reducer, B: Reducer> Reducer for ReduceA2<A, B>

type Item = Sum2<A::Item, B::Item>

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

type Async = ReduceA2Async<A::Async, B::Async>

fn into_async(self) -> Self::Async

impl<A: Reducer, B: Reducer> Reducer for ReduceC2<A, B>

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

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

type Async = ReduceC2Async<A::Async, B::Async>

fn into_async(self) -> Self::Async

impl<A: Reducer, B: Reducer, C: Reducer> Reducer for ReduceA3<A, B, C>

type Item = Sum3<A::Item, B::Item, C::Item>

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

type Async = ReduceA3Async<A::Async, B::Async, C::Async>

fn into_async(self) -> Self::Async

impl<A: Reducer, B: Reducer, C: Reducer> Reducer for ReduceC3<A, B, C>

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

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

type Async = ReduceC3Async<A::Async, B::Async, C::Async>

fn into_async(self) -> Self::Async

impl<A: Reducer, B: Reducer, C: Reducer, D: Reducer> Reducer for ReduceA4<A, B, C, D>

type Item = Sum4<A::Item, B::Item, C::Item, D::Item>

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

type Async = ReduceA4Async<A::Async, B::Async, C::Async, D::Async>

fn into_async(self) -> Self::Async

impl<A: Reducer, B: Reducer, C: Reducer, D: Reducer> Reducer for ReduceC4<A, B, C, D>

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

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

type Async = ReduceC4Async<A::Async, B::Async, C::Async, D::Async>

fn into_async(self) -> Self::Async

impl<A: Reducer, B: Reducer, C: Reducer, D: Reducer, E: Reducer> Reducer for ReduceA5<A, B, C, D, E>

type Item = Sum5<A::Item, B::Item, C::Item, D::Item, E::Item>

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

type Async = ReduceA5Async<A::Async, B::Async, C::Async, D::Async, E::Async>

fn into_async(self) -> Self::Async

impl<A: Reducer, B: Reducer, C: Reducer, D: Reducer, E: Reducer> Reducer for ReduceC5<A, B, C, D, E>

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

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

type Async = ReduceC5Async<A::Async, B::Async, C::Async, D::Async, E::Async>

fn into_async(self) -> Self::Async

impl<A: Reducer, B: Reducer, C: Reducer, D: Reducer, E: Reducer, F: Reducer> Reducer for ReduceA6<A, B, C, D, E, F>

type Item = Sum6<A::Item, B::Item, C::Item, D::Item, E::Item, F::Item>

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

type Async = ReduceA6Async<A::Async, B::Async, C::Async, D::Async, E::Async, F::Async>

fn into_async(self) -> Self::Async

impl<A: Reducer, B: Reducer, C: Reducer, D: Reducer, E: Reducer, F: Reducer> Reducer for ReduceC6<A, B, C, D, E, F>

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

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

type Async = ReduceC6Async<A::Async, B::Async, C::Async, D::Async, E::Async, F::Async>

fn into_async(self) -> Self::Async

impl<A: Reducer, B: Reducer, C: Reducer, D: Reducer, E: Reducer, F: Reducer, G: Reducer> Reducer for ReduceA7<A, B, C, D, E, F, G>

type Item = Sum7<A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item>

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

type Async = ReduceA7Async<A::Async, B::Async, C::Async, D::Async, E::Async, F::Async, G::Async>

fn into_async(self) -> Self::Async

impl<A: Reducer, B: Reducer, C: Reducer, D: Reducer, E: Reducer, F: Reducer, G: Reducer> Reducer for ReduceC7<A, B, C, D, E, F, G>

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

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

type Async = ReduceC7Async<A::Async, B::Async, C::Async, D::Async, E::Async, F::Async, G::Async>

fn into_async(self) -> Self::Async

impl<A: Reducer, B: Reducer, C: Reducer, D: Reducer, E: Reducer, F: Reducer, G: Reducer, H: Reducer> Reducer for ReduceA8<A, B, C, D, E, F, G, H>

type Item = Sum8<A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item>

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

type Async = ReduceA8Async<A::Async, B::Async, C::Async, D::Async, E::Async, F::Async, G::Async, H::Async>

fn into_async(self) -> Self::Async

impl<A: Reducer, B: Reducer, C: Reducer, D: Reducer, E: Reducer, F: Reducer, G: Reducer, H: Reducer> Reducer for ReduceC8<A, B, C, D, E, F, G, H>

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

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

type Async = ReduceC8Async<A::Async, B::Async, C::Async, D::Async, E::Async, F::Async, G::Async, H::Async>

fn into_async(self) -> Self::Async

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

type Item = A

type Output = T

type Async = Self

fn into_async(self) -> Self::Async

impl<R: Reducer> Reducer for OptionReducer<R>

type Item = Option<R::Item>

type Output = Option<R::Output>

type Async = OptionReducer<R::Async>

fn into_async(self) -> Self::Async

impl<R: Reducer, E> Reducer for ResultReducer<R, E>

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

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

type Async = ResultReducerAsync<R::Async, E>

fn into_async(self) -> Self::Async

impl<R: Reducer, T> Reducer for IntoReducer<R, T> where
    R::Output: Into<T>, 

type Item = R::Item

type Output = T

type Async = IntoReducer<R::Async, T>

fn into_async(self) -> Self::Async

Loading content...