[−][src]Trait amadeus::par_sink::DistributedSink

#[must_use]pub trait DistributedSink<Source> where
    <Self::ReduceAFactory as Factory>::Item == Self::ReduceA,
    <Self::ReduceBFactory as Factory>::Item == Self::ReduceB,
    <Self::ReduceA as Reducer>::Item == <Self::Pipe as DistributedPipe<Source>>::Item,
    <Self::ReduceB as Reducer>::Item == <Self::ReduceA as Reducer>::Output,
    <Self::ReduceC as Reducer>::Item == <Self::ReduceB as Reducer>::Output,
    <Self::ReduceC as Reducer>::Output == Self::Output, {
    type Output;
    type Pipe: DistributedPipe<Source>;
    type ReduceAFactory: Factory + ProcessSend + Clone;
    type ReduceBFactory: Factory;
    type ReduceA: ReducerSend + Send;
    type ReduceB: ReducerProcessSend + ProcessSend;
    type ReduceC: Reducer;
    fn reducers(
        self
    ) -> (Self::Pipe, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC);
}

Associated Types

`type Output`

`type Pipe: DistributedPipe<Source>`

`type ReduceAFactory: Factory + ProcessSend + Clone`

`type ReduceBFactory: Factory`

`type ReduceA: ReducerSend + Send`

`type ReduceB: ReducerProcessSend + ProcessSend`

`type ReduceC: Reducer`

Loading content...

Required methods

`fn reducers( self ) -> (Self::Pipe, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)`

Loading content...

Implementations on Foreign Types

impl<Source, R0, R1, R2, R3, R4, R5, R6, R7, O0, O1, O2, O3, O4, O5, O6, O7> DistributedSink<Source> for (R0, R1, R2, R3, R4, R5, R6, R7) where R0: DistributedSink<Source, Output = O0>, R1: DistributedSink<Source, Output = O1>, R2: DistributedSink<Source, Output = O2>, R3: DistributedSink<Source, Output = O3>, R4: DistributedSink<Source, Output = O4>, R5: DistributedSink<Source, Output = O5>, R6: DistributedSink<Source, Output = O6>, R7: DistributedSink<Source, Output = O7>, Source: Copy, [src]

`type Output = (O0, O1, O2, O3, O4, O5, O6, O7)`

`type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe, <R2 as DistributedSink<Source>>::Pipe, <R3 as DistributedSink<Source>>::Pipe, <R4 as DistributedSink<Source>>::Pipe, <R5 as DistributedSink<Source>>::Pipe, <R6 as DistributedSink<Source>>::Pipe, <R7 as DistributedSink<Source>>::Pipe)`

`type ReduceAFactory = ReduceA8Factory<<R0 as DistributedSink<Source>>::ReduceAFactory, <R1 as DistributedSink<Source>>::ReduceAFactory, <R2 as DistributedSink<Source>>::ReduceAFactory, <R3 as DistributedSink<Source>>::ReduceAFactory, <R4 as DistributedSink<Source>>::ReduceAFactory, <R5 as DistributedSink<Source>>::ReduceAFactory, <R6 as DistributedSink<Source>>::ReduceAFactory, <R7 as DistributedSink<Source>>::ReduceAFactory>`

`type ReduceBFactory = ReduceC8Factory<<R0 as DistributedSink<Source>>::ReduceBFactory, <R1 as DistributedSink<Source>>::ReduceBFactory, <R2 as DistributedSink<Source>>::ReduceBFactory, <R3 as DistributedSink<Source>>::ReduceBFactory, <R4 as DistributedSink<Source>>::ReduceBFactory, <R5 as DistributedSink<Source>>::ReduceBFactory, <R6 as DistributedSink<Source>>::ReduceBFactory, <R7 as DistributedSink<Source>>::ReduceBFactory>`

`type ReduceA = ReduceA8<<R0 as DistributedSink<Source>>::ReduceA, <R1 as DistributedSink<Source>>::ReduceA, <R2 as DistributedSink<Source>>::ReduceA, <R3 as DistributedSink<Source>>::ReduceA, <R4 as DistributedSink<Source>>::ReduceA, <R5 as DistributedSink<Source>>::ReduceA, <R6 as DistributedSink<Source>>::ReduceA, <R7 as DistributedSink<Source>>::ReduceA>`

`type ReduceB = ReduceC8<<R0 as DistributedSink<Source>>::ReduceB, <R1 as DistributedSink<Source>>::ReduceB, <R2 as DistributedSink<Source>>::ReduceB, <R3 as DistributedSink<Source>>::ReduceB, <R4 as DistributedSink<Source>>::ReduceB, <R5 as DistributedSink<Source>>::ReduceB, <R6 as DistributedSink<Source>>::ReduceB, <R7 as DistributedSink<Source>>::ReduceB>`

`type ReduceC = ReduceC8<<R0 as DistributedSink<Source>>::ReduceC, <R1 as DistributedSink<Source>>::ReduceC, <R2 as DistributedSink<Source>>::ReduceC, <R3 as DistributedSink<Source>>::ReduceC, <R4 as DistributedSink<Source>>::ReduceC, <R5 as DistributedSink<Source>>::ReduceC, <R6 as DistributedSink<Source>>::ReduceC, <R7 as DistributedSink<Source>>::ReduceC>`

`fn reducers( self ) -> (<(R0, R1, R2, R3, R4, R5, R6, R7) as DistributedSink<Source>>::Pipe, <(R0, R1, R2, R3, R4, R5, R6, R7) as DistributedSink<Source>>::ReduceAFactory, <(R0, R1, R2, R3, R4, R5, R6, R7) as DistributedSink<Source>>::ReduceBFactory, <(R0, R1, R2, R3, R4, R5, R6, R7) as DistributedSink<Source>>::ReduceC)`[src]

`impl<Source, R0, R1, R2, R3, O0, O1, O2, O3> DistributedSink<Source> for (R0, R1, R2, R3) where R0: DistributedSink<Source, Output = O0>, R1: DistributedSink<Source, Output = O1>, R2: DistributedSink<Source, Output = O2>, R3: DistributedSink<Source, Output = O3>, Source: Copy,` [src]

`type Output = (O0, O1, O2, O3)`

`type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe, <R2 as DistributedSink<Source>>::Pipe, <R3 as DistributedSink<Source>>::Pipe)`

`type ReduceAFactory = ReduceA4Factory<<R0 as DistributedSink<Source>>::ReduceAFactory, <R1 as DistributedSink<Source>>::ReduceAFactory, <R2 as DistributedSink<Source>>::ReduceAFactory, <R3 as DistributedSink<Source>>::ReduceAFactory>`

`type ReduceBFactory = ReduceC4Factory<<R0 as DistributedSink<Source>>::ReduceBFactory, <R1 as DistributedSink<Source>>::ReduceBFactory, <R2 as DistributedSink<Source>>::ReduceBFactory, <R3 as DistributedSink<Source>>::ReduceBFactory>`

`type ReduceA = ReduceA4<<R0 as DistributedSink<Source>>::ReduceA, <R1 as DistributedSink<Source>>::ReduceA, <R2 as DistributedSink<Source>>::ReduceA, <R3 as DistributedSink<Source>>::ReduceA>`

`type ReduceB = ReduceC4<<R0 as DistributedSink<Source>>::ReduceB, <R1 as DistributedSink<Source>>::ReduceB, <R2 as DistributedSink<Source>>::ReduceB, <R3 as DistributedSink<Source>>::ReduceB>`

`type ReduceC = ReduceC4<<R0 as DistributedSink<Source>>::ReduceC, <R1 as DistributedSink<Source>>::ReduceC, <R2 as DistributedSink<Source>>::ReduceC, <R3 as DistributedSink<Source>>::ReduceC>`

`fn reducers( self ) -> (<(R0, R1, R2, R3) as DistributedSink<Source>>::Pipe, <(R0, R1, R2, R3) as DistributedSink<Source>>::ReduceAFactory, <(R0, R1, R2, R3) as DistributedSink<Source>>::ReduceBFactory, <(R0, R1, R2, R3) as DistributedSink<Source>>::ReduceC)`[src]

`impl<Source, R0, R1, O0, O1> DistributedSink<Source> for (R0, R1) where R0: DistributedSink<Source, Output = O0>, R1: DistributedSink<Source, Output = O1>, Source: Copy,` [src]

`type Output = (O0, O1)`

`type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe)`

`type ReduceAFactory = ReduceA2Factory<<R0 as DistributedSink<Source>>::ReduceAFactory, <R1 as DistributedSink<Source>>::ReduceAFactory>`

`type ReduceBFactory = ReduceC2Factory<<R0 as DistributedSink<Source>>::ReduceBFactory, <R1 as DistributedSink<Source>>::ReduceBFactory>`

`type ReduceA = ReduceA2<<R0 as DistributedSink<Source>>::ReduceA, <R1 as DistributedSink<Source>>::ReduceA>`

`type ReduceB = ReduceC2<<R0 as DistributedSink<Source>>::ReduceB, <R1 as DistributedSink<Source>>::ReduceB>`

`type ReduceC = ReduceC2<<R0 as DistributedSink<Source>>::ReduceC, <R1 as DistributedSink<Source>>::ReduceC>`

`fn reducers( self ) -> (<(R0, R1) as DistributedSink<Source>>::Pipe, <(R0, R1) as DistributedSink<Source>>::ReduceAFactory, <(R0, R1) as DistributedSink<Source>>::ReduceBFactory, <(R0, R1) as DistributedSink<Source>>::ReduceC)`[src]

`impl<Source, R0, R1, R2, R3, R4, R5, O0, O1, O2, O3, O4, O5> DistributedSink<Source> for (R0, R1, R2, R3, R4, R5) where R0: DistributedSink<Source, Output = O0>, R1: DistributedSink<Source, Output = O1>, R2: DistributedSink<Source, Output = O2>, R3: DistributedSink<Source, Output = O3>, R4: DistributedSink<Source, Output = O4>, R5: DistributedSink<Source, Output = O5>, Source: Copy,` [src]

`type Output = (O0, O1, O2, O3, O4, O5)`

`type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe, <R2 as DistributedSink<Source>>::Pipe, <R3 as DistributedSink<Source>>::Pipe, <R4 as DistributedSink<Source>>::Pipe, <R5 as DistributedSink<Source>>::Pipe)`

`type ReduceAFactory = ReduceA6Factory<<R0 as DistributedSink<Source>>::ReduceAFactory, <R1 as DistributedSink<Source>>::ReduceAFactory, <R2 as DistributedSink<Source>>::ReduceAFactory, <R3 as DistributedSink<Source>>::ReduceAFactory, <R4 as DistributedSink<Source>>::ReduceAFactory, <R5 as DistributedSink<Source>>::ReduceAFactory>`

`type ReduceBFactory = ReduceC6Factory<<R0 as DistributedSink<Source>>::ReduceBFactory, <R1 as DistributedSink<Source>>::ReduceBFactory, <R2 as DistributedSink<Source>>::ReduceBFactory, <R3 as DistributedSink<Source>>::ReduceBFactory, <R4 as DistributedSink<Source>>::ReduceBFactory, <R5 as DistributedSink<Source>>::ReduceBFactory>`

`type ReduceA = ReduceA6<<R0 as DistributedSink<Source>>::ReduceA, <R1 as DistributedSink<Source>>::ReduceA, <R2 as DistributedSink<Source>>::ReduceA, <R3 as DistributedSink<Source>>::ReduceA, <R4 as DistributedSink<Source>>::ReduceA, <R5 as DistributedSink<Source>>::ReduceA>`

`type ReduceB = ReduceC6<<R0 as DistributedSink<Source>>::ReduceB, <R1 as DistributedSink<Source>>::ReduceB, <R2 as DistributedSink<Source>>::ReduceB, <R3 as DistributedSink<Source>>::ReduceB, <R4 as DistributedSink<Source>>::ReduceB, <R5 as DistributedSink<Source>>::ReduceB>`

`type ReduceC = ReduceC6<<R0 as DistributedSink<Source>>::ReduceC, <R1 as DistributedSink<Source>>::ReduceC, <R2 as DistributedSink<Source>>::ReduceC, <R3 as DistributedSink<Source>>::ReduceC, <R4 as DistributedSink<Source>>::ReduceC, <R5 as DistributedSink<Source>>::ReduceC>`

`fn reducers( self ) -> (<(R0, R1, R2, R3, R4, R5) as DistributedSink<Source>>::Pipe, <(R0, R1, R2, R3, R4, R5) as DistributedSink<Source>>::ReduceAFactory, <(R0, R1, R2, R3, R4, R5) as DistributedSink<Source>>::ReduceBFactory, <(R0, R1, R2, R3, R4, R5) as DistributedSink<Source>>::ReduceC)`[src]

impl<Source, R0, R1, R2, R3, R4, R5, R6, O0, O1, O2, O3, O4, O5, O6> DistributedSink<Source> for (R0, R1, R2, R3, R4, R5, R6) where R0: DistributedSink<Source, Output = O0>, R1: DistributedSink<Source, Output = O1>, R2: DistributedSink<Source, Output = O2>, R3: DistributedSink<Source, Output = O3>, R4: DistributedSink<Source, Output = O4>, R5: DistributedSink<Source, Output = O5>, R6: DistributedSink<Source, Output = O6>, Source: Copy, [src]

`type Output = (O0, O1, O2, O3, O4, O5, O6)`

`type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe, <R2 as DistributedSink<Source>>::Pipe, <R3 as DistributedSink<Source>>::Pipe, <R4 as DistributedSink<Source>>::Pipe, <R5 as DistributedSink<Source>>::Pipe, <R6 as DistributedSink<Source>>::Pipe)`

`type ReduceAFactory = ReduceA7Factory<<R0 as DistributedSink<Source>>::ReduceAFactory, <R1 as DistributedSink<Source>>::ReduceAFactory, <R2 as DistributedSink<Source>>::ReduceAFactory, <R3 as DistributedSink<Source>>::ReduceAFactory, <R4 as DistributedSink<Source>>::ReduceAFactory, <R5 as DistributedSink<Source>>::ReduceAFactory, <R6 as DistributedSink<Source>>::ReduceAFactory>`

`type ReduceBFactory = ReduceC7Factory<<R0 as DistributedSink<Source>>::ReduceBFactory, <R1 as DistributedSink<Source>>::ReduceBFactory, <R2 as DistributedSink<Source>>::ReduceBFactory, <R3 as DistributedSink<Source>>::ReduceBFactory, <R4 as DistributedSink<Source>>::ReduceBFactory, <R5 as DistributedSink<Source>>::ReduceBFactory, <R6 as DistributedSink<Source>>::ReduceBFactory>`

`type ReduceA = ReduceA7<<R0 as DistributedSink<Source>>::ReduceA, <R1 as DistributedSink<Source>>::ReduceA, <R2 as DistributedSink<Source>>::ReduceA, <R3 as DistributedSink<Source>>::ReduceA, <R4 as DistributedSink<Source>>::ReduceA, <R5 as DistributedSink<Source>>::ReduceA, <R6 as DistributedSink<Source>>::ReduceA>`

`type ReduceB = ReduceC7<<R0 as DistributedSink<Source>>::ReduceB, <R1 as DistributedSink<Source>>::ReduceB, <R2 as DistributedSink<Source>>::ReduceB, <R3 as DistributedSink<Source>>::ReduceB, <R4 as DistributedSink<Source>>::ReduceB, <R5 as DistributedSink<Source>>::ReduceB, <R6 as DistributedSink<Source>>::ReduceB>`

`type ReduceC = ReduceC7<<R0 as DistributedSink<Source>>::ReduceC, <R1 as DistributedSink<Source>>::ReduceC, <R2 as DistributedSink<Source>>::ReduceC, <R3 as DistributedSink<Source>>::ReduceC, <R4 as DistributedSink<Source>>::ReduceC, <R5 as DistributedSink<Source>>::ReduceC, <R6 as DistributedSink<Source>>::ReduceC>`

`fn reducers( self ) -> (<(R0, R1, R2, R3, R4, R5, R6) as DistributedSink<Source>>::Pipe, <(R0, R1, R2, R3, R4, R5, R6) as DistributedSink<Source>>::ReduceAFactory, <(R0, R1, R2, R3, R4, R5, R6) as DistributedSink<Source>>::ReduceBFactory, <(R0, R1, R2, R3, R4, R5, R6) as DistributedSink<Source>>::ReduceC)`[src]

`impl<Source, R0, O0> DistributedSink<Source> for (R0,) where R0: DistributedSink<Source, Output = O0>,` [src]

`type Output = (O0,)`

`type Pipe = (<R0 as DistributedSink<Source>>::Pipe,)`

`type ReduceAFactory = ReduceA1Factory<<R0 as DistributedSink<Source>>::ReduceAFactory>`

`type ReduceBFactory = ReduceC1Factory<<R0 as DistributedSink<Source>>::ReduceBFactory>`

`type ReduceA = ReduceA1<<R0 as DistributedSink<Source>>::ReduceA>`

`type ReduceB = ReduceC1<<R0 as DistributedSink<Source>>::ReduceB>`

`type ReduceC = ReduceC1<<R0 as DistributedSink<Source>>::ReduceC>`

`fn reducers( self ) -> (<(R0,) as DistributedSink<Source>>::Pipe, <(R0,) as DistributedSink<Source>>::ReduceAFactory, <(R0,) as DistributedSink<Source>>::ReduceBFactory, <(R0,) as DistributedSink<Source>>::ReduceC)`[src]

`impl<Source, R0, R1, R2, R3, R4, O0, O1, O2, O3, O4> DistributedSink<Source> for (R0, R1, R2, R3, R4) where R0: DistributedSink<Source, Output = O0>, R1: DistributedSink<Source, Output = O1>, R2: DistributedSink<Source, Output = O2>, R3: DistributedSink<Source, Output = O3>, R4: DistributedSink<Source, Output = O4>, Source: Copy,` [src]

`type Output = (O0, O1, O2, O3, O4)`

`type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe, <R2 as DistributedSink<Source>>::Pipe, <R3 as DistributedSink<Source>>::Pipe, <R4 as DistributedSink<Source>>::Pipe)`

`type ReduceAFactory = ReduceA5Factory<<R0 as DistributedSink<Source>>::ReduceAFactory, <R1 as DistributedSink<Source>>::ReduceAFactory, <R2 as DistributedSink<Source>>::ReduceAFactory, <R3 as DistributedSink<Source>>::ReduceAFactory, <R4 as DistributedSink<Source>>::ReduceAFactory>`

`type ReduceBFactory = ReduceC5Factory<<R0 as DistributedSink<Source>>::ReduceBFactory, <R1 as DistributedSink<Source>>::ReduceBFactory, <R2 as DistributedSink<Source>>::ReduceBFactory, <R3 as DistributedSink<Source>>::ReduceBFactory, <R4 as DistributedSink<Source>>::ReduceBFactory>`

`type ReduceA = ReduceA5<<R0 as DistributedSink<Source>>::ReduceA, <R1 as DistributedSink<Source>>::ReduceA, <R2 as DistributedSink<Source>>::ReduceA, <R3 as DistributedSink<Source>>::ReduceA, <R4 as DistributedSink<Source>>::ReduceA>`

`type ReduceB = ReduceC5<<R0 as DistributedSink<Source>>::ReduceB, <R1 as DistributedSink<Source>>::ReduceB, <R2 as DistributedSink<Source>>::ReduceB, <R3 as DistributedSink<Source>>::ReduceB, <R4 as DistributedSink<Source>>::ReduceB>`

`type ReduceC = ReduceC5<<R0 as DistributedSink<Source>>::ReduceC, <R1 as DistributedSink<Source>>::ReduceC, <R2 as DistributedSink<Source>>::ReduceC, <R3 as DistributedSink<Source>>::ReduceC, <R4 as DistributedSink<Source>>::ReduceC>`

`fn reducers( self ) -> (<(R0, R1, R2, R3, R4) as DistributedSink<Source>>::Pipe, <(R0, R1, R2, R3, R4) as DistributedSink<Source>>::ReduceAFactory, <(R0, R1, R2, R3, R4) as DistributedSink<Source>>::ReduceBFactory, <(R0, R1, R2, R3, R4) as DistributedSink<Source>>::ReduceC)`[src]

`impl<Source, R0, R1, R2, O0, O1, O2> DistributedSink<Source> for (R0, R1, R2) where R0: DistributedSink<Source, Output = O0>, R1: DistributedSink<Source, Output = O1>, R2: DistributedSink<Source, Output = O2>, Source: Copy,` [src]

`type Output = (O0, O1, O2)`

`type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe, <R2 as DistributedSink<Source>>::Pipe)`

`type ReduceAFactory = ReduceA3Factory<<R0 as DistributedSink<Source>>::ReduceAFactory, <R1 as DistributedSink<Source>>::ReduceAFactory, <R2 as DistributedSink<Source>>::ReduceAFactory>`

`type ReduceBFactory = ReduceC3Factory<<R0 as DistributedSink<Source>>::ReduceBFactory, <R1 as DistributedSink<Source>>::ReduceBFactory, <R2 as DistributedSink<Source>>::ReduceBFactory>`

`type ReduceA = ReduceA3<<R0 as DistributedSink<Source>>::ReduceA, <R1 as DistributedSink<Source>>::ReduceA, <R2 as DistributedSink<Source>>::ReduceA>`

`type ReduceB = ReduceC3<<R0 as DistributedSink<Source>>::ReduceB, <R1 as DistributedSink<Source>>::ReduceB, <R2 as DistributedSink<Source>>::ReduceB>`

`type ReduceC = ReduceC3<<R0 as DistributedSink<Source>>::ReduceC, <R1 as DistributedSink<Source>>::ReduceC, <R2 as DistributedSink<Source>>::ReduceC>`

`fn reducers( self ) -> (<(R0, R1, R2) as DistributedSink<Source>>::Pipe, <(R0, R1, R2) as DistributedSink<Source>>::ReduceAFactory, <(R0, R1, R2) as DistributedSink<Source>>::ReduceBFactory, <(R0, R1, R2) as DistributedSink<Source>>::ReduceC)`[src]

`impl<Source> DistributedSink<Source> for ()`[src]

`type Output = ()`

`type Pipe = ()`

`type ReduceAFactory = ReduceA0Factory`

`type ReduceBFactory = ReduceC0Factory`

`type ReduceA = ReduceA0`

`type ReduceB = ReduceC0`

`type ReduceC = ReduceC0`

`fn reducers( self ) -> (<() as DistributedSink<Source>>::Pipe, <() as DistributedSink<Source>>::ReduceAFactory, <() as DistributedSink<Source>>::ReduceBFactory, <() as DistributedSink<Source>>::ReduceC)`[src]

Loading content...

Implementors

`impl<A, B, Source> DistributedSink<Source> for Pipe<A, B> where A: DistributedPipe<Source>, B: DistributedSink<<A as DistributedPipe<Source>>::Item>,` [src]

`type Output = >::Item>>::Output`

`type Pipe = Pipe<A, >::Item>>::Pipe>`

`type ReduceAFactory = >::Item>>::ReduceAFactory`

`type ReduceBFactory = >::Item>>::ReduceBFactory`

`type ReduceA = >::Item>>::ReduceA`

`type ReduceB = >::Item>>::ReduceB`

`type ReduceC = >::Item>>::ReduceC`

`fn reducers( self ) -> (<Pipe<A, B> as DistributedSink<Source>>::Pipe, <Pipe<A, B> as DistributedSink<Source>>::ReduceAFactory, <Pipe<A, B> as DistributedSink<Source>>::ReduceBFactory, <Pipe<A, B> as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source> DistributedSink<Source> for Count where I: DistributedPipe<Source>,` [src]

`type Output = <<Count as DistributedSink<Source>>::ReduceC as Reducer>::Output`

`type Pipe = I`

`type ReduceAFactory = FolderSyncReducerFactory<>::Item, CountFolder>`

`type ReduceBFactory = FolderSyncReducerFactory<<<Count as DistributedSink<Source>>::ReduceA as Reducer>::Output, SumFolder<usize>>`

`type ReduceA = FolderSyncReducer<>::Item, CountFolder>`

`type ReduceB = FolderSyncReducer<<<Count as DistributedSink<Source>>::ReduceA as Reducer>::Output, SumFolder<usize>>`

`type ReduceC = FolderSyncReducer<<<Count as DistributedSink<Source>>::ReduceB as Reducer>::Output, SumFolder<usize>>`

`fn reducers( self ) -> (I, <Count as DistributedSink<Source>>::ReduceAFactory, <Count as DistributedSink<Source>>::ReduceBFactory, <Count as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source> DistributedSink<Source> for Histogram where I: DistributedPipe<Source>, >::Item: Hash, >::Item: Ord, >::Item: ProcessSend, >::Item: 'static,` [src]

`type Output = <<Histogram as DistributedSink<Source>>::ReduceC as Reducer>::Output`

`type Pipe = I`

`type ReduceAFactory = FolderSyncReducerFactory<>::Item, HistogramFolder<>::Item, StepA>>`

`type ReduceBFactory = FolderSyncReducerFactory<<<Histogram as DistributedSink<Source>>::ReduceA as Reducer>::Output, HistogramFolder<>::Item, StepB>>`

`type ReduceA = FolderSyncReducer<>::Item, HistogramFolder<>::Item, StepA>>`

`type ReduceB = FolderSyncReducer<<<Histogram as DistributedSink<Source>>::ReduceA as Reducer>::Output, HistogramFolder<>::Item, StepB>>`

`type ReduceC = FolderSyncReducer<<<Histogram as DistributedSink<Source>>::ReduceB as Reducer>::Output, HistogramFolder<>::Item, StepB>>`

`fn reducers( self ) -> (I, <Histogram as DistributedSink<Source>>::ReduceAFactory, <Histogram as DistributedSink<Source>>::ReduceBFactory, <Histogram as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source> DistributedSink<Source> for Max where I: DistributedPipe<Source>, >::Item: Ord, >::Item: ProcessSend, >::Item: 'static,` [src]

`type Output = <<Max as DistributedSink<Source>>::ReduceC as Reducer>::Output`

`type Pipe = I`

`type ReduceAFactory = FolderSyncReducerFactory<>::Item, Max<>::Item>>`

`type ReduceBFactory = FolderSyncReducerFactory<<<Max as DistributedSink<Source>>::ReduceA as Reducer>::Output, Max<>::Item>>`

`type ReduceA = FolderSyncReducer<>::Item, Max<>::Item>>`

`type ReduceB = FolderSyncReducer<<<Max as DistributedSink<Source>>::ReduceA as Reducer>::Output, Max<>::Item>>`

`type ReduceC = FolderSyncReducer<<<Max as DistributedSink<Source>>::ReduceB as Reducer>::Output, Max<>::Item>>`

`fn reducers( self ) -> (I, <Max as DistributedSink<Source>>::ReduceAFactory, <Max as DistributedSink<Source>>::ReduceBFactory, <Max as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source> DistributedSink<Source> for Min where I: DistributedPipe<Source>, >::Item: Ord, >::Item: ProcessSend, >::Item: 'static,` [src]

`type Output = <<Min as DistributedSink<Source>>::ReduceC as Reducer>::Output`

`type Pipe = I`

`type ReduceAFactory = FolderSyncReducerFactory<>::Item, Min<>::Item>>`

`type ReduceBFactory = FolderSyncReducerFactory<<<Min as DistributedSink<Source>>::ReduceA as Reducer>::Output, Min<>::Item>>`

`type ReduceA = FolderSyncReducer<>::Item, Min<>::Item>>`

`type ReduceB = FolderSyncReducer<<<Min as DistributedSink<Source>>::ReduceA as Reducer>::Output, Min<>::Item>>`

`type ReduceC = FolderSyncReducer<<<Min as DistributedSink<Source>>::ReduceB as Reducer>::Output, Min<>::Item>>`

`fn reducers( self ) -> (I, <Min as DistributedSink<Source>>::ReduceAFactory, <Min as DistributedSink<Source>>::ReduceBFactory, <Min as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source> DistributedSink<Source> for MostFrequent where I: DistributedPipe<Source>, >::Item: Clone, >::Item: Hash, >::Item: Eq, >::Item: ProcessSend, >::Item: 'static,` [src]

`type Output = <<MostFrequent as DistributedSink<Source>>::ReduceC as Reducer>::Output`

`type Pipe = I`

`type ReduceAFactory = FolderSyncReducerFactory<>::Item, MostFrequentFolder>`

`type ReduceBFactory = FolderSyncReducerFactory<<<MostFrequent as DistributedSink<Source>>::ReduceA as Reducer>::Output, SumZeroFolder<Top<>::Item, usize>>>`

`type ReduceA = FolderSyncReducer<>::Item, MostFrequentFolder>`

`type ReduceB = FolderSyncReducer<<<MostFrequent as DistributedSink<Source>>::ReduceA as Reducer>::Output, SumZeroFolder<Top<>::Item, usize>>>`

`type ReduceC = FolderSyncReducer<<<MostFrequent as DistributedSink<Source>>::ReduceB as Reducer>::Output, SumZeroFolder<Top<>::Item, usize>>>`

`fn reducers( self ) -> (I, <MostFrequent as DistributedSink<Source>>::ReduceAFactory, <MostFrequent as DistributedSink<Source>>::ReduceBFactory, <MostFrequent as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source> DistributedSink<Source> for SampleUnstable where I: DistributedPipe<Source>, >::Item: ProcessSend, >::Item: 'static,` [src]

`type Output = <<SampleUnstable as DistributedSink<Source>>::ReduceC as Reducer>::Output`

`type Pipe = I`

`type ReduceAFactory = FolderSyncReducerFactory<>::Item, SampleUnstableFolder>`

`type ReduceBFactory = FolderSyncReducerFactory<<<SampleUnstable as DistributedSink<Source>>::ReduceA as Reducer>::Output, SumFolder<SampleUnstable<>::Item>>>`

`type ReduceA = FolderSyncReducer<>::Item, SampleUnstableFolder>`

`type ReduceB = FolderSyncReducer<<<SampleUnstable as DistributedSink<Source>>::ReduceA as Reducer>::Output, SumFolder<SampleUnstable<>::Item>>>`

`type ReduceC = FolderSyncReducer<<<SampleUnstable as DistributedSink<Source>>::ReduceB as Reducer>::Output, SumFolder<SampleUnstable<>::Item>>>`

`fn reducers( self ) -> (I, <SampleUnstable as DistributedSink<Source>>::ReduceAFactory, <SampleUnstable as DistributedSink<Source>>::ReduceBFactory, <SampleUnstable as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source, A, B> DistributedSink<Source> for MostDistinct where A: Clone + Hash + Eq + ProcessSend + 'static, B: Hash + 'static, I: DistributedPipe<Source, Item = (A, B)>,` [src]

`type Output = <<MostDistinct as DistributedSink<Source>>::ReduceC as Reducer>::Output`

`type Pipe = I`

`type ReduceAFactory = FolderSyncReducerFactory<>::Item, MostDistinctFolder>`

`type ReduceBFactory = FolderSyncReducerFactory<<<MostDistinct as DistributedSink<Source>>::ReduceA as Reducer>::Output, SumZeroFolder<Top<A, HyperLogLogMagnitude>>>`

`type ReduceA = FolderSyncReducer<>::Item, MostDistinctFolder>`

`type ReduceB = FolderSyncReducer<<<MostDistinct as DistributedSink<Source>>::ReduceA as Reducer>::Output, SumZeroFolder<Top<A, HyperLogLogMagnitude>>>`

`type ReduceC = FolderSyncReducer<<<MostDistinct as DistributedSink<Source>>::ReduceB as Reducer>::Output, SumZeroFolder<Top<A, HyperLogLogMagnitude>>>`

`fn reducers( self ) -> (I, <MostDistinct as DistributedSink<Source>>::ReduceAFactory, <MostDistinct as DistributedSink<Source>>::ReduceBFactory, <MostDistinct as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source, A, B, ID, F, C> DistributedSink<Source> for GroupBy<I, ID, F, C> where A: Eq + Hash + ProcessSend + 'static, C: ProcessSend + 'static, F: FnMut(C, Either<B, C>) -> C + Clone + ProcessSend + 'static, I: DistributedPipe<Source, Item = (A, B)>, ID: FnMut() -> C + Clone + ProcessSend + 'static,` [src]

`type Output = <<GroupBy<I, ID, F, C> as DistributedSink<Source>>::ReduceC as Reducer>::Output`

`type Pipe = I`

`type ReduceAFactory = FolderSyncReducerFactory<>::Item, GroupByFolder<A, B, ID, F, C, StepA>>`

`type ReduceBFactory = FolderSyncReducerFactory<<<GroupBy<I, ID, F, C> as DistributedSink<Source>>::ReduceA as Reducer>::Output, GroupByFolder<A, B, ID, F, C, StepB>>`

`type ReduceA = FolderSyncReducer<>::Item, GroupByFolder<A, B, ID, F, C, StepA>>`

`type ReduceB = FolderSyncReducer<<<GroupBy<I, ID, F, C> as DistributedSink<Source>>::ReduceA as Reducer>::Output, GroupByFolder<A, B, ID, F, C, StepB>>`

`type ReduceC = FolderSyncReducer<<<GroupBy<I, ID, F, C> as DistributedSink<Source>>::ReduceB as Reducer>::Output, GroupByFolder<A, B, ID, F, C, StepB>>`

`fn reducers( self ) -> (I, <GroupBy<I, ID, F, C> as DistributedSink<Source>>::ReduceAFactory, <GroupBy<I, ID, F, C> as DistributedSink<Source>>::ReduceBFactory, <GroupBy<I, ID, F, C> as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source, B> DistributedSink<Source> for Sum<I, B> where B: Sum<>::Item> + Sum + ProcessSend + 'static, I: DistributedPipe<Source>,` [src]

`type Output = <<Sum<I, B> as DistributedSink<Source>>::ReduceC as Reducer>::Output`

`type Pipe = I`

`type ReduceAFactory = FolderSyncReducerFactory<>::Item, SumFolder>`

`type ReduceBFactory = FolderSyncReducerFactory<<<Sum<I, B> as DistributedSink<Source>>::ReduceA as Reducer>::Output, SumFolder>`

`type ReduceA = FolderSyncReducer<>::Item, SumFolder>`

`type ReduceB = FolderSyncReducer<<<Sum<I, B> as DistributedSink<Source>>::ReduceA as Reducer>::Output, SumFolder>`

`type ReduceC = FolderSyncReducer<<<Sum<I, B> as DistributedSink<Source>>::ReduceB as Reducer>::Output, SumFolder>`

`fn reducers( self ) -> (I, <Sum<I, B> as DistributedSink<Source>>::ReduceAFactory, <Sum<I, B> as DistributedSink<Source>>::ReduceBFactory, <Sum<I, B> as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source, F> DistributedSink<Source> for All<I, F> where F: FnMut(>::Item) -> bool + Clone + ProcessSend + 'static, I: DistributedPipe<Source>,` [src]

`type Output = bool`

`type Pipe = I`

`type ReduceAFactory = AllReducerFactory<>::Item, F>`

`type ReduceBFactory = BoolAndReducerFactory`

`type ReduceA = AllReducer<>::Item, F>`

`type ReduceB = BoolAndReducer`

`type ReduceC = BoolAndReducer`

`fn reducers( self ) -> (<All<I, F> as DistributedSink<Source>>::Pipe, <All<I, F> as DistributedSink<Source>>::ReduceAFactory, <All<I, F> as DistributedSink<Source>>::ReduceBFactory, <All<I, F> as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source, F> DistributedSink<Source> for Any<I, F> where F: FnMut(>::Item) -> bool + Clone + ProcessSend + 'static, I: DistributedPipe<Source>,` [src]

`type Output = bool`

`type Pipe = I`

`type ReduceAFactory = AnyReducerFactory<>::Item, F>`

`type ReduceBFactory = BoolOrReducerFactory`

`type ReduceA = AnyReducer<>::Item, F>`

`type ReduceB = BoolOrReducer`

`type ReduceC = BoolOrReducer`

`fn reducers( self ) -> (<Any<I, F> as DistributedSink<Source>>::Pipe, <Any<I, F> as DistributedSink<Source>>::ReduceAFactory, <Any<I, F> as DistributedSink<Source>>::ReduceBFactory, <Any<I, F> as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source, F> DistributedSink<Source> for Combine<I, F> where F: FnMut(>::Item, >::Item) -> >::Item + Clone + ProcessSend + 'static, I: DistributedPipe<Source>, >::Item: ProcessSend, >::Item: 'static,` [src]

`type Output = <<Combine<I, F> as DistributedSink<Source>>::ReduceC as Reducer>::Output`

`type Pipe = I`

`type ReduceAFactory = FolderSyncReducerFactory<>::Item, ReduceFn<F, >::Item>>`

`type ReduceBFactory = FolderSyncReducerFactory<<<Combine<I, F> as DistributedSink<Source>>::ReduceA as Reducer>::Output, ReduceFn<F, >::Item>>`

`type ReduceA = FolderSyncReducer<>::Item, ReduceFn<F, >::Item>>`

`type ReduceB = FolderSyncReducer<<<Combine<I, F> as DistributedSink<Source>>::ReduceA as Reducer>::Output, ReduceFn<F, >::Item>>`

`type ReduceC = FolderSyncReducer<<<Combine<I, F> as DistributedSink<Source>>::ReduceB as Reducer>::Output, ReduceFn<F, >::Item>>`

`fn reducers( self ) -> (I, <Combine<I, F> as DistributedSink<Source>>::ReduceAFactory, <Combine<I, F> as DistributedSink<Source>>::ReduceBFactory, <Combine<I, F> as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source, F> DistributedSink<Source> for ForEach<I, F> where F: FnMut(>::Item) + Clone + ProcessSend + 'static, I: DistributedPipe<Source>,` [src]

`type Output = ()`

`type Pipe = I`

`type ReduceAFactory = ForEachReducerFactory<>::Item, F>`

`type ReduceBFactory = DefaultReducerFactory<<ForEach<I, F> as DistributedSink<Source>>::ReduceB>`

`type ReduceA = ForEachReducer<>::Item, F>`

`type ReduceB = PushReducer<(), ()>`

`type ReduceC = PushReducer<(), ()>`

`fn reducers( self ) -> (<ForEach<I, F> as DistributedSink<Source>>::Pipe, <ForEach<I, F> as DistributedSink<Source>>::ReduceAFactory, <ForEach<I, F> as DistributedSink<Source>>::ReduceBFactory, <ForEach<I, F> as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source, F> DistributedSink<Source> for MaxBy<I, F> where F: FnMut(&>::Item, &>::Item) -> Ordering + Clone + ProcessSend + 'static, I: DistributedPipe<Source>, >::Item: ProcessSend, >::Item: 'static,` [src]

`type Output = <<MaxBy<I, F> as DistributedSink<Source>>::ReduceC as Reducer>::Output`

`type Pipe = I`

`type ReduceAFactory = FolderSyncReducerFactory<>::Item, MaxBy<>::Item, F>>`

`type ReduceBFactory = FolderSyncReducerFactory<<<MaxBy<I, F> as DistributedSink<Source>>::ReduceA as Reducer>::Output, MaxBy<>::Item, F>>`

`type ReduceA = FolderSyncReducer<>::Item, MaxBy<>::Item, F>>`

`type ReduceB = FolderSyncReducer<<<MaxBy<I, F> as DistributedSink<Source>>::ReduceA as Reducer>::Output, MaxBy<>::Item, F>>`

`type ReduceC = FolderSyncReducer<<<MaxBy<I, F> as DistributedSink<Source>>::ReduceB as Reducer>::Output, MaxBy<>::Item, F>>`

`fn reducers( self ) -> (I, <MaxBy<I, F> as DistributedSink<Source>>::ReduceAFactory, <MaxBy<I, F> as DistributedSink<Source>>::ReduceBFactory, <MaxBy<I, F> as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source, F> DistributedSink<Source> for MinBy<I, F> where F: FnMut(&>::Item, &>::Item) -> Ordering + Clone + ProcessSend + 'static, I: DistributedPipe<Source>, >::Item: ProcessSend, >::Item: 'static,` [src]

`type Output = <<MinBy<I, F> as DistributedSink<Source>>::ReduceC as Reducer>::Output`

`type Pipe = I`

`type ReduceAFactory = FolderSyncReducerFactory<>::Item, MinBy<>::Item, F>>`

`type ReduceBFactory = FolderSyncReducerFactory<<<MinBy<I, F> as DistributedSink<Source>>::ReduceA as Reducer>::Output, MinBy<>::Item, F>>`

`type ReduceA = FolderSyncReducer<>::Item, MinBy<>::Item, F>>`

`type ReduceB = FolderSyncReducer<<<MinBy<I, F> as DistributedSink<Source>>::ReduceA as Reducer>::Output, MinBy<>::Item, F>>`

`type ReduceC = FolderSyncReducer<<<MinBy<I, F> as DistributedSink<Source>>::ReduceB as Reducer>::Output, MinBy<>::Item, F>>`

`fn reducers( self ) -> (I, <MinBy<I, F> as DistributedSink<Source>>::ReduceAFactory, <MinBy<I, F> as DistributedSink<Source>>::ReduceBFactory, <MinBy<I, F> as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source, F, B> DistributedSink<Source> for MaxByKey<I, F> where B: Ord + 'static, F: FnMut(&>::Item) -> B + Clone + ProcessSend + 'static, I: DistributedPipe<Source>, >::Item: ProcessSend, >::Item: 'static,` [src]

`type Output = <<MaxByKey<I, F> as DistributedSink<Source>>::ReduceC as Reducer>::Output`

`type Pipe = I`

`type ReduceAFactory = FolderSyncReducerFactory<>::Item, MaxByKey<>::Item, F, B>>`

`type ReduceBFactory = FolderSyncReducerFactory<<<MaxByKey<I, F> as DistributedSink<Source>>::ReduceA as Reducer>::Output, MaxByKey<>::Item, F, B>>`

`type ReduceA = FolderSyncReducer<>::Item, MaxByKey<>::Item, F, B>>`

`type ReduceB = FolderSyncReducer<<<MaxByKey<I, F> as DistributedSink<Source>>::ReduceA as Reducer>::Output, MaxByKey<>::Item, F, B>>`

`type ReduceC = FolderSyncReducer<<<MaxByKey<I, F> as DistributedSink<Source>>::ReduceB as Reducer>::Output, MaxByKey<>::Item, F, B>>`

`fn reducers( self ) -> (I, <MaxByKey<I, F> as DistributedSink<Source>>::ReduceAFactory, <MaxByKey<I, F> as DistributedSink<Source>>::ReduceBFactory, <MaxByKey<I, F> as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source, F, B> DistributedSink<Source> for MinByKey<I, F> where B: Ord + 'static, F: FnMut(&>::Item) -> B + Clone + ProcessSend + 'static, I: DistributedPipe<Source>, >::Item: ProcessSend, >::Item: 'static,` [src]

`type Output = <<MinByKey<I, F> as DistributedSink<Source>>::ReduceC as Reducer>::Output`

`type Pipe = I`

`type ReduceAFactory = FolderSyncReducerFactory<>::Item, MinByKey<>::Item, F, B>>`

`type ReduceBFactory = FolderSyncReducerFactory<<<MinByKey<I, F> as DistributedSink<Source>>::ReduceA as Reducer>::Output, MinByKey<>::Item, F, B>>`

`type ReduceA = FolderSyncReducer<>::Item, MinByKey<>::Item, F, B>>`

`type ReduceB = FolderSyncReducer<<<MinByKey<I, F> as DistributedSink<Source>>::ReduceA as Reducer>::Output, MinByKey<>::Item, F, B>>`

`type ReduceC = FolderSyncReducer<<<MinByKey<I, F> as DistributedSink<Source>>::ReduceB as Reducer>::Output, MinByKey<>::Item, F, B>>`

`fn reducers( self ) -> (I, <MinByKey<I, F> as DistributedSink<Source>>::ReduceAFactory, <MinByKey<I, F> as DistributedSink<Source>>::ReduceBFactory, <MinByKey<I, F> as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source, ID, F, B> DistributedSink<Source> for Fold<I, ID, F, B> where B: ProcessSend + 'static, F: FnMut(B, Either<>::Item, B>) -> B + Clone + ProcessSend + 'static, I: DistributedPipe<Source>, ID: FnMut() -> B + Clone + ProcessSend + 'static,` [src]

`type Output = <<Fold<I, ID, F, B> as DistributedSink<Source>>::ReduceC as Reducer>::Output`

`type Pipe = I`

`type ReduceAFactory = FolderSyncReducerFactory<>::Item, FoldFolder<>::Item, ID, F, B, StepA>>`

`type ReduceBFactory = FolderSyncReducerFactory<<<Fold<I, ID, F, B> as DistributedSink<Source>>::ReduceA as Reducer>::Output, FoldFolder<>::Item, ID, F, B, StepB>>`

`type ReduceA = FolderSyncReducer<>::Item, FoldFolder<>::Item, ID, F, B, StepA>>`

`type ReduceB = FolderSyncReducer<<<Fold<I, ID, F, B> as DistributedSink<Source>>::ReduceA as Reducer>::Output, FoldFolder<>::Item, ID, F, B, StepB>>`

`type ReduceC = FolderSyncReducer<<<Fold<I, ID, F, B> as DistributedSink<Source>>::ReduceB as Reducer>::Output, FoldFolder<>::Item, ID, F, B, StepB>>`

`fn reducers( self ) -> (I, <Fold<I, ID, F, B> as DistributedSink<Source>>::ReduceAFactory, <Fold<I, ID, F, B> as DistributedSink<Source>>::ReduceBFactory, <Fold<I, ID, F, B> as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source, T> DistributedSink<Source> for Collect<I, T> where I: DistributedPipe<Source>, T: FromDistributedStream<>::Item>,` [src]

`type Output = T`

`type Pipe = I`

`type ReduceAFactory = <T as FromDistributedStream<>::Item>>::ReduceAFactory`

`type ReduceBFactory = <T as FromDistributedStream<>::Item>>::ReduceBFactory`

`type ReduceA = <T as FromDistributedStream<>::Item>>::ReduceA`

`type ReduceB = <T as FromDistributedStream<>::Item>>::ReduceB`

`type ReduceC = <T as FromDistributedStream<>::Item>>::ReduceC`

`fn reducers( self ) -> (<Collect<I, T> as DistributedSink<Source>>::Pipe, <Collect<I, T> as DistributedSink<Source>>::ReduceAFactory, <Collect<I, T> as DistributedSink<Source>>::ReduceBFactory, <Collect<I, T> as DistributedSink<Source>>::ReduceC)`[src]

Loading content...

[−][src]Trait amadeus::par_sink::DistributedSink

Associated Types

type Output

type Pipe: DistributedPipe<Source>

type ReduceAFactory: Factory + ProcessSend + Clone

type ReduceBFactory: Factory

type ReduceA: ReducerSend + Send

type ReduceB: ReducerProcessSend + ProcessSend

type ReduceC: Reducer

Required methods

fn reducers( self) -> (Self::Pipe, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)

Implementations on Foreign Types

type Output = (O0, O1, O2, O3, O4, O5, O6, O7)

impl<Source, R0, R1, R2, R3, O0, O1, O2, O3> DistributedSink<Source> for (R0, R1, R2, R3) where R0: DistributedSink<Source, Output = O0>, R1: DistributedSink<Source, Output = O1>, R2: DistributedSink<Source, Output = O2>, R3: DistributedSink<Source, Output = O3>, Source: Copy, [src]

type Output = (O0, O1, O2, O3)

type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe, <R2 as DistributedSink<Source>>::Pipe, <R3 as DistributedSink<Source>>::Pipe)

type ReduceAFactory = ReduceA4Factory<<R0 as DistributedSink<Source>>::ReduceAFactory, <R1 as DistributedSink<Source>>::ReduceAFactory, <R2 as DistributedSink<Source>>::ReduceAFactory, <R3 as DistributedSink<Source>>::ReduceAFactory>

type ReduceBFactory = ReduceC4Factory<<R0 as DistributedSink<Source>>::ReduceBFactory, <R1 as DistributedSink<Source>>::ReduceBFactory, <R2 as DistributedSink<Source>>::ReduceBFactory, <R3 as DistributedSink<Source>>::ReduceBFactory>

type ReduceA = ReduceA4<<R0 as DistributedSink<Source>>::ReduceA, <R1 as DistributedSink<Source>>::ReduceA, <R2 as DistributedSink<Source>>::ReduceA, <R3 as DistributedSink<Source>>::ReduceA>

type ReduceB = ReduceC4<<R0 as DistributedSink<Source>>::ReduceB, <R1 as DistributedSink<Source>>::ReduceB, <R2 as DistributedSink<Source>>::ReduceB, <R3 as DistributedSink<Source>>::ReduceB>

type ReduceC = ReduceC4<<R0 as DistributedSink<Source>>::ReduceC, <R1 as DistributedSink<Source>>::ReduceC, <R2 as DistributedSink<Source>>::ReduceC, <R3 as DistributedSink<Source>>::ReduceC>

fn reducers( self) -> (<(R0, R1, R2, R3) as DistributedSink<Source>>::Pipe, <(R0, R1, R2, R3) as DistributedSink<Source>>::ReduceAFactory, <(R0, R1, R2, R3) as DistributedSink<Source>>::ReduceBFactory, <(R0, R1, R2, R3) as DistributedSink<Source>>::ReduceC)[src]

impl<Source, R0, R1, O0, O1> DistributedSink<Source> for (R0, R1) where R0: DistributedSink<Source, Output = O0>, R1: DistributedSink<Source, Output = O1>, Source: Copy, [src]

type Output = (O0, O1)

type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe)

type ReduceAFactory = ReduceA2Factory<<R0 as DistributedSink<Source>>::ReduceAFactory, <R1 as DistributedSink<Source>>::ReduceAFactory>

type ReduceBFactory = ReduceC2Factory<<R0 as DistributedSink<Source>>::ReduceBFactory, <R1 as DistributedSink<Source>>::ReduceBFactory>

type ReduceA = ReduceA2<<R0 as DistributedSink<Source>>::ReduceA, <R1 as DistributedSink<Source>>::ReduceA>

type ReduceB = ReduceC2<<R0 as DistributedSink<Source>>::ReduceB, <R1 as DistributedSink<Source>>::ReduceB>

type ReduceC = ReduceC2<<R0 as DistributedSink<Source>>::ReduceC, <R1 as DistributedSink<Source>>::ReduceC>

fn reducers( self) -> (<(R0, R1) as DistributedSink<Source>>::Pipe, <(R0, R1) as DistributedSink<Source>>::ReduceAFactory, <(R0, R1) as DistributedSink<Source>>::ReduceBFactory, <(R0, R1) as DistributedSink<Source>>::ReduceC)[src]

type Output = (O0, O1, O2, O3, O4, O5)

type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe, <R2 as DistributedSink<Source>>::Pipe, <R3 as DistributedSink<Source>>::Pipe, <R4 as DistributedSink<Source>>::Pipe, <R5 as DistributedSink<Source>>::Pipe)

type ReduceA = ReduceA6<<R0 as DistributedSink<Source>>::ReduceA, <R1 as DistributedSink<Source>>::ReduceA, <R2 as DistributedSink<Source>>::ReduceA, <R3 as DistributedSink<Source>>::ReduceA, <R4 as DistributedSink<Source>>::ReduceA, <R5 as DistributedSink<Source>>::ReduceA>

type ReduceB = ReduceC6<<R0 as DistributedSink<Source>>::ReduceB, <R1 as DistributedSink<Source>>::ReduceB, <R2 as DistributedSink<Source>>::ReduceB, <R3 as DistributedSink<Source>>::ReduceB, <R4 as DistributedSink<Source>>::ReduceB, <R5 as DistributedSink<Source>>::ReduceB>

type ReduceC = ReduceC6<<R0 as DistributedSink<Source>>::ReduceC, <R1 as DistributedSink<Source>>::ReduceC, <R2 as DistributedSink<Source>>::ReduceC, <R3 as DistributedSink<Source>>::ReduceC, <R4 as DistributedSink<Source>>::ReduceC, <R5 as DistributedSink<Source>>::ReduceC>

fn reducers( self) -> (<(R0, R1, R2, R3, R4, R5) as DistributedSink<Source>>::Pipe, <(R0, R1, R2, R3, R4, R5) as DistributedSink<Source>>::ReduceAFactory, <(R0, R1, R2, R3, R4, R5) as DistributedSink<Source>>::ReduceBFactory, <(R0, R1, R2, R3, R4, R5) as DistributedSink<Source>>::ReduceC)[src]

type Output = (O0, O1, O2, O3, O4, O5, O6)

type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe, <R2 as DistributedSink<Source>>::Pipe, <R3 as DistributedSink<Source>>::Pipe, <R4 as DistributedSink<Source>>::Pipe, <R5 as DistributedSink<Source>>::Pipe, <R6 as DistributedSink<Source>>::Pipe)

impl<Source, R0, O0> DistributedSink<Source> for (R0,) where R0: DistributedSink<Source, Output = O0>, [src]

type Output = (O0,)

type Pipe = (<R0 as DistributedSink<Source>>::Pipe,)

type ReduceAFactory = ReduceA1Factory<<R0 as DistributedSink<Source>>::ReduceAFactory>

type ReduceBFactory = ReduceC1Factory<<R0 as DistributedSink<Source>>::ReduceBFactory>

type ReduceA = ReduceA1<<R0 as DistributedSink<Source>>::ReduceA>

type ReduceB = ReduceC1<<R0 as DistributedSink<Source>>::ReduceB>

type ReduceC = ReduceC1<<R0 as DistributedSink<Source>>::ReduceC>

fn reducers( self) -> (<(R0,) as DistributedSink<Source>>::Pipe, <(R0,) as DistributedSink<Source>>::ReduceAFactory, <(R0,) as DistributedSink<Source>>::ReduceBFactory, <(R0,) as DistributedSink<Source>>::ReduceC)[src]

type Output = (O0, O1, O2, O3, O4)

type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe, <R2 as DistributedSink<Source>>::Pipe, <R3 as DistributedSink<Source>>::Pipe, <R4 as DistributedSink<Source>>::Pipe)

type ReduceAFactory = ReduceA5Factory<<R0 as DistributedSink<Source>>::ReduceAFactory, <R1 as DistributedSink<Source>>::ReduceAFactory, <R2 as DistributedSink<Source>>::ReduceAFactory, <R3 as DistributedSink<Source>>::ReduceAFactory, <R4 as DistributedSink<Source>>::ReduceAFactory>

type ReduceBFactory = ReduceC5Factory<<R0 as DistributedSink<Source>>::ReduceBFactory, <R1 as DistributedSink<Source>>::ReduceBFactory, <R2 as DistributedSink<Source>>::ReduceBFactory, <R3 as DistributedSink<Source>>::ReduceBFactory, <R4 as DistributedSink<Source>>::ReduceBFactory>

type ReduceA = ReduceA5<<R0 as DistributedSink<Source>>::ReduceA, <R1 as DistributedSink<Source>>::ReduceA, <R2 as DistributedSink<Source>>::ReduceA, <R3 as DistributedSink<Source>>::ReduceA, <R4 as DistributedSink<Source>>::ReduceA>

type ReduceB = ReduceC5<<R0 as DistributedSink<Source>>::ReduceB, <R1 as DistributedSink<Source>>::ReduceB, <R2 as DistributedSink<Source>>::ReduceB, <R3 as DistributedSink<Source>>::ReduceB, <R4 as DistributedSink<Source>>::ReduceB>

type ReduceC = ReduceC5<<R0 as DistributedSink<Source>>::ReduceC, <R1 as DistributedSink<Source>>::ReduceC, <R2 as DistributedSink<Source>>::ReduceC, <R3 as DistributedSink<Source>>::ReduceC, <R4 as DistributedSink<Source>>::ReduceC>

fn reducers( self) -> (<(R0, R1, R2, R3, R4) as DistributedSink<Source>>::Pipe, <(R0, R1, R2, R3, R4) as DistributedSink<Source>>::ReduceAFactory, <(R0, R1, R2, R3, R4) as DistributedSink<Source>>::ReduceBFactory, <(R0, R1, R2, R3, R4) as DistributedSink<Source>>::ReduceC)[src]

impl<Source, R0, R1, R2, O0, O1, O2> DistributedSink<Source> for (R0, R1, R2) where R0: DistributedSink<Source, Output = O0>, R1: DistributedSink<Source, Output = O1>, R2: DistributedSink<Source, Output = O2>, Source: Copy, [src]

type Output = (O0, O1, O2)

type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe, <R2 as DistributedSink<Source>>::Pipe)

type ReduceAFactory = ReduceA3Factory<<R0 as DistributedSink<Source>>::ReduceAFactory, <R1 as DistributedSink<Source>>::ReduceAFactory, <R2 as DistributedSink<Source>>::ReduceAFactory>

type ReduceBFactory = ReduceC3Factory<<R0 as DistributedSink<Source>>::ReduceBFactory, <R1 as DistributedSink<Source>>::ReduceBFactory, <R2 as DistributedSink<Source>>::ReduceBFactory>

type ReduceA = ReduceA3<<R0 as DistributedSink<Source>>::ReduceA, <R1 as DistributedSink<Source>>::ReduceA, <R2 as DistributedSink<Source>>::ReduceA>

type ReduceB = ReduceC3<<R0 as DistributedSink<Source>>::ReduceB, <R1 as DistributedSink<Source>>::ReduceB, <R2 as DistributedSink<Source>>::ReduceB>

type ReduceC = ReduceC3<<R0 as DistributedSink<Source>>::ReduceC, <R1 as DistributedSink<Source>>::ReduceC, <R2 as DistributedSink<Source>>::ReduceC>

fn reducers( self) -> (<(R0, R1, R2) as DistributedSink<Source>>::Pipe, <(R0, R1, R2) as DistributedSink<Source>>::ReduceAFactory, <(R0, R1, R2) as DistributedSink<Source>>::ReduceBFactory, <(R0, R1, R2) as DistributedSink<Source>>::ReduceC)[src]

impl<Source> DistributedSink<Source> for ()[src]

type Output = ()

type Pipe = ()

type ReduceAFactory = ReduceA0Factory

type ReduceBFactory = ReduceC0Factory

type ReduceA = ReduceA0

type ReduceB = ReduceC0

type ReduceC = ReduceC0

fn reducers( self) -> (<() as DistributedSink<Source>>::Pipe, <() as DistributedSink<Source>>::ReduceAFactory, <() as DistributedSink<Source>>::ReduceBFactory, <() as DistributedSink<Source>>::ReduceC)[src]

Implementors

impl<A, B, Source> DistributedSink<Source> for Pipe<A, B> where A: DistributedPipe<Source>, B: DistributedSink<<A as DistributedPipe<Source>>::Item>, [src]

type Output = <B as DistributedSink<<A as DistributedPipe<Source>>::Item>>::Output

type Pipe = Pipe<A, <B as DistributedSink<<A as DistributedPipe<Source>>::Item>>::Pipe>

type ReduceAFactory = <B as DistributedSink<<A as DistributedPipe<Source>>::Item>>::ReduceAFactory

type ReduceBFactory = <B as DistributedSink<<A as DistributedPipe<Source>>::Item>>::ReduceBFactory

`type Output`

`type Pipe: DistributedPipe<Source>`

`type ReduceAFactory: Factory + ProcessSend + Clone`

`type ReduceBFactory: Factory`

`type ReduceA: ReducerSend + Send`

`type ReduceB: ReducerProcessSend + ProcessSend`

`type ReduceC: Reducer`

`fn reducers( self ) -> (Self::Pipe, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)`

`type Output = (O0, O1, O2, O3, O4, O5, O6, O7)`

`impl<Source, R0, R1, R2, R3, O0, O1, O2, O3> DistributedSink<Source> for (R0, R1, R2, R3) where R0: DistributedSink<Source, Output = O0>, R1: DistributedSink<Source, Output = O1>, R2: DistributedSink<Source, Output = O2>, R3: DistributedSink<Source, Output = O3>, Source: Copy,` [src]

`type Output = (O0, O1, O2, O3)`

`type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe, <R2 as DistributedSink<Source>>::Pipe, <R3 as DistributedSink<Source>>::Pipe)`

`type ReduceAFactory = ReduceA4Factory<<R0 as DistributedSink<Source>>::ReduceAFactory, <R1 as DistributedSink<Source>>::ReduceAFactory, <R2 as DistributedSink<Source>>::ReduceAFactory, <R3 as DistributedSink<Source>>::ReduceAFactory>`

`type ReduceBFactory = ReduceC4Factory<<R0 as DistributedSink<Source>>::ReduceBFactory, <R1 as DistributedSink<Source>>::ReduceBFactory, <R2 as DistributedSink<Source>>::ReduceBFactory, <R3 as DistributedSink<Source>>::ReduceBFactory>`

`type ReduceA = ReduceA4<<R0 as DistributedSink<Source>>::ReduceA, <R1 as DistributedSink<Source>>::ReduceA, <R2 as DistributedSink<Source>>::ReduceA, <R3 as DistributedSink<Source>>::ReduceA>`

`type ReduceB = ReduceC4<<R0 as DistributedSink<Source>>::ReduceB, <R1 as DistributedSink<Source>>::ReduceB, <R2 as DistributedSink<Source>>::ReduceB, <R3 as DistributedSink<Source>>::ReduceB>`

`type ReduceC = ReduceC4<<R0 as DistributedSink<Source>>::ReduceC, <R1 as DistributedSink<Source>>::ReduceC, <R2 as DistributedSink<Source>>::ReduceC, <R3 as DistributedSink<Source>>::ReduceC>`

`fn reducers( self ) -> (<(R0, R1, R2, R3) as DistributedSink<Source>>::Pipe, <(R0, R1, R2, R3) as DistributedSink<Source>>::ReduceAFactory, <(R0, R1, R2, R3) as DistributedSink<Source>>::ReduceBFactory, <(R0, R1, R2, R3) as DistributedSink<Source>>::ReduceC)`[src]

`impl<Source, R0, R1, O0, O1> DistributedSink<Source> for (R0, R1) where R0: DistributedSink<Source, Output = O0>, R1: DistributedSink<Source, Output = O1>, Source: Copy,` [src]

`type Output = (O0, O1)`

`type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe)`

`type ReduceAFactory = ReduceA2Factory<<R0 as DistributedSink<Source>>::ReduceAFactory, <R1 as DistributedSink<Source>>::ReduceAFactory>`

`type ReduceBFactory = ReduceC2Factory<<R0 as DistributedSink<Source>>::ReduceBFactory, <R1 as DistributedSink<Source>>::ReduceBFactory>`

`type ReduceA = ReduceA2<<R0 as DistributedSink<Source>>::ReduceA, <R1 as DistributedSink<Source>>::ReduceA>`

`type ReduceB = ReduceC2<<R0 as DistributedSink<Source>>::ReduceB, <R1 as DistributedSink<Source>>::ReduceB>`

`type ReduceC = ReduceC2<<R0 as DistributedSink<Source>>::ReduceC, <R1 as DistributedSink<Source>>::ReduceC>`

`fn reducers( self ) -> (<(R0, R1) as DistributedSink<Source>>::Pipe, <(R0, R1) as DistributedSink<Source>>::ReduceAFactory, <(R0, R1) as DistributedSink<Source>>::ReduceBFactory, <(R0, R1) as DistributedSink<Source>>::ReduceC)`[src]

`type Output = (O0, O1, O2, O3, O4, O5)`

`type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe, <R2 as DistributedSink<Source>>::Pipe, <R3 as DistributedSink<Source>>::Pipe, <R4 as DistributedSink<Source>>::Pipe, <R5 as DistributedSink<Source>>::Pipe)`

`type ReduceA = ReduceA6<<R0 as DistributedSink<Source>>::ReduceA, <R1 as DistributedSink<Source>>::ReduceA, <R2 as DistributedSink<Source>>::ReduceA, <R3 as DistributedSink<Source>>::ReduceA, <R4 as DistributedSink<Source>>::ReduceA, <R5 as DistributedSink<Source>>::ReduceA>`

`type ReduceB = ReduceC6<<R0 as DistributedSink<Source>>::ReduceB, <R1 as DistributedSink<Source>>::ReduceB, <R2 as DistributedSink<Source>>::ReduceB, <R3 as DistributedSink<Source>>::ReduceB, <R4 as DistributedSink<Source>>::ReduceB, <R5 as DistributedSink<Source>>::ReduceB>`

`type ReduceC = ReduceC6<<R0 as DistributedSink<Source>>::ReduceC, <R1 as DistributedSink<Source>>::ReduceC, <R2 as DistributedSink<Source>>::ReduceC, <R3 as DistributedSink<Source>>::ReduceC, <R4 as DistributedSink<Source>>::ReduceC, <R5 as DistributedSink<Source>>::ReduceC>`

`fn reducers( self ) -> (<(R0, R1, R2, R3, R4, R5) as DistributedSink<Source>>::Pipe, <(R0, R1, R2, R3, R4, R5) as DistributedSink<Source>>::ReduceAFactory, <(R0, R1, R2, R3, R4, R5) as DistributedSink<Source>>::ReduceBFactory, <(R0, R1, R2, R3, R4, R5) as DistributedSink<Source>>::ReduceC)`[src]

`type Output = (O0, O1, O2, O3, O4, O5, O6)`

`type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe, <R2 as DistributedSink<Source>>::Pipe, <R3 as DistributedSink<Source>>::Pipe, <R4 as DistributedSink<Source>>::Pipe, <R5 as DistributedSink<Source>>::Pipe, <R6 as DistributedSink<Source>>::Pipe)`

`impl<Source, R0, O0> DistributedSink<Source> for (R0,) where R0: DistributedSink<Source, Output = O0>,` [src]

`type Output = (O0,)`

`type Pipe = (<R0 as DistributedSink<Source>>::Pipe,)`

`type ReduceAFactory = ReduceA1Factory<<R0 as DistributedSink<Source>>::ReduceAFactory>`

`type ReduceBFactory = ReduceC1Factory<<R0 as DistributedSink<Source>>::ReduceBFactory>`

`type ReduceA = ReduceA1<<R0 as DistributedSink<Source>>::ReduceA>`

`type ReduceB = ReduceC1<<R0 as DistributedSink<Source>>::ReduceB>`

`type ReduceC = ReduceC1<<R0 as DistributedSink<Source>>::ReduceC>`

`fn reducers( self ) -> (<(R0,) as DistributedSink<Source>>::Pipe, <(R0,) as DistributedSink<Source>>::ReduceAFactory, <(R0,) as DistributedSink<Source>>::ReduceBFactory, <(R0,) as DistributedSink<Source>>::ReduceC)`[src]

`type Output = (O0, O1, O2, O3, O4)`

`type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe, <R2 as DistributedSink<Source>>::Pipe, <R3 as DistributedSink<Source>>::Pipe, <R4 as DistributedSink<Source>>::Pipe)`

`type ReduceAFactory = ReduceA5Factory<<R0 as DistributedSink<Source>>::ReduceAFactory, <R1 as DistributedSink<Source>>::ReduceAFactory, <R2 as DistributedSink<Source>>::ReduceAFactory, <R3 as DistributedSink<Source>>::ReduceAFactory, <R4 as DistributedSink<Source>>::ReduceAFactory>`

`type ReduceBFactory = ReduceC5Factory<<R0 as DistributedSink<Source>>::ReduceBFactory, <R1 as DistributedSink<Source>>::ReduceBFactory, <R2 as DistributedSink<Source>>::ReduceBFactory, <R3 as DistributedSink<Source>>::ReduceBFactory, <R4 as DistributedSink<Source>>::ReduceBFactory>`

`type ReduceA = ReduceA5<<R0 as DistributedSink<Source>>::ReduceA, <R1 as DistributedSink<Source>>::ReduceA, <R2 as DistributedSink<Source>>::ReduceA, <R3 as DistributedSink<Source>>::ReduceA, <R4 as DistributedSink<Source>>::ReduceA>`

`type ReduceB = ReduceC5<<R0 as DistributedSink<Source>>::ReduceB, <R1 as DistributedSink<Source>>::ReduceB, <R2 as DistributedSink<Source>>::ReduceB, <R3 as DistributedSink<Source>>::ReduceB, <R4 as DistributedSink<Source>>::ReduceB>`

`type ReduceC = ReduceC5<<R0 as DistributedSink<Source>>::ReduceC, <R1 as DistributedSink<Source>>::ReduceC, <R2 as DistributedSink<Source>>::ReduceC, <R3 as DistributedSink<Source>>::ReduceC, <R4 as DistributedSink<Source>>::ReduceC>`

`fn reducers( self ) -> (<(R0, R1, R2, R3, R4) as DistributedSink<Source>>::Pipe, <(R0, R1, R2, R3, R4) as DistributedSink<Source>>::ReduceAFactory, <(R0, R1, R2, R3, R4) as DistributedSink<Source>>::ReduceBFactory, <(R0, R1, R2, R3, R4) as DistributedSink<Source>>::ReduceC)`[src]

`impl<Source, R0, R1, R2, O0, O1, O2> DistributedSink<Source> for (R0, R1, R2) where R0: DistributedSink<Source, Output = O0>, R1: DistributedSink<Source, Output = O1>, R2: DistributedSink<Source, Output = O2>, Source: Copy,` [src]

`type Output = (O0, O1, O2)`

`type Pipe = (<R0 as DistributedSink<Source>>::Pipe, <R1 as DistributedSink<Source>>::Pipe, <R2 as DistributedSink<Source>>::Pipe)`

`type ReduceAFactory = ReduceA3Factory<<R0 as DistributedSink<Source>>::ReduceAFactory, <R1 as DistributedSink<Source>>::ReduceAFactory, <R2 as DistributedSink<Source>>::ReduceAFactory>`

`type ReduceBFactory = ReduceC3Factory<<R0 as DistributedSink<Source>>::ReduceBFactory, <R1 as DistributedSink<Source>>::ReduceBFactory, <R2 as DistributedSink<Source>>::ReduceBFactory>`

`type ReduceA = ReduceA3<<R0 as DistributedSink<Source>>::ReduceA, <R1 as DistributedSink<Source>>::ReduceA, <R2 as DistributedSink<Source>>::ReduceA>`

`type ReduceB = ReduceC3<<R0 as DistributedSink<Source>>::ReduceB, <R1 as DistributedSink<Source>>::ReduceB, <R2 as DistributedSink<Source>>::ReduceB>`

`type ReduceC = ReduceC3<<R0 as DistributedSink<Source>>::ReduceC, <R1 as DistributedSink<Source>>::ReduceC, <R2 as DistributedSink<Source>>::ReduceC>`

`fn reducers( self ) -> (<(R0, R1, R2) as DistributedSink<Source>>::Pipe, <(R0, R1, R2) as DistributedSink<Source>>::ReduceAFactory, <(R0, R1, R2) as DistributedSink<Source>>::ReduceBFactory, <(R0, R1, R2) as DistributedSink<Source>>::ReduceC)`[src]

`impl<Source> DistributedSink<Source> for ()`[src]

`type Output = ()`

`type Pipe = ()`

`type ReduceAFactory = ReduceA0Factory`

`type ReduceBFactory = ReduceC0Factory`

`type ReduceA = ReduceA0`

`type ReduceB = ReduceC0`

`type ReduceC = ReduceC0`

`fn reducers( self ) -> (<() as DistributedSink<Source>>::Pipe, <() as DistributedSink<Source>>::ReduceAFactory, <() as DistributedSink<Source>>::ReduceBFactory, <() as DistributedSink<Source>>::ReduceC)`[src]

`impl<A, B, Source> DistributedSink<Source> for Pipe<A, B> where A: DistributedPipe<Source>, B: DistributedSink<<A as DistributedPipe<Source>>::Item>,` [src]

`type Output = <B as DistributedSink<<A as DistributedPipe<Source>>::Item>>::Output`

`type Pipe = Pipe<A, <B as DistributedSink<<A as DistributedPipe<Source>>::Item>>::Pipe>`

`type ReduceAFactory = <B as DistributedSink<<A as DistributedPipe<Source>>::Item>>::ReduceAFactory`

`type ReduceBFactory = <B as DistributedSink<<A as DistributedPipe<Source>>::Item>>::ReduceBFactory`

`type ReduceA = <B as DistributedSink<<A as DistributedPipe<Source>>::Item>>::ReduceA`

`type ReduceB = <B as DistributedSink<<A as DistributedPipe<Source>>::Item>>::ReduceB`

`type ReduceC = <B as DistributedSink<<A as DistributedPipe<Source>>::Item>>::ReduceC`

`fn reducers( self ) -> (<Pipe<A, B> as DistributedSink<Source>>::Pipe, <Pipe<A, B> as DistributedSink<Source>>::ReduceAFactory, <Pipe<A, B> as DistributedSink<Source>>::ReduceBFactory, <Pipe<A, B> as DistributedSink<Source>>::ReduceC)`[src]

`impl<I, Source> DistributedSink<Source> for Count<I> where I: DistributedPipe<Source>,` [src]