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

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

Associated Types

type Output

type Pipe: DistributedPipe<Source>

type ReduceAFactory: Factory<Item = Self::ReduceA> + Clone + ProcessSend

type ReduceBFactory: Factory<Item = Self::ReduceB>

type ReduceA: ReducerSend<Item = <Self::Pipe as DistributedPipe<Source>>::Item> + Send

type ReduceB: ReducerProcessSend<Item = <Self::ReduceA as Reducer>::Output> + ProcessSend

type ReduceC: Reducer<Item = <Self::ReduceB as Reducer>::Output, Output = Self::Output>

Loading content...

Required methods

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

Loading content...

Implementations on Foreign Types

impl<Source> DistributedSink<Source> for () where
    Source: , [src]

type Output = ()

type Pipe = ()

type ReduceAFactory = ReduceA0Factory

type ReduceBFactory = ReduceC0Factory

type ReduceA = ReduceA0

type ReduceB = ReduceC0

type ReduceC = ReduceC0

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

type Output = (O0,)

type Pipe = (R0::Pipe,)

type ReduceAFactory = ReduceA1Factory<R0::ReduceAFactory>

type ReduceBFactory = ReduceC1Factory<R0::ReduceBFactory>

type ReduceA = ReduceA1<R0::ReduceA>

type ReduceB = ReduceC1<R0::ReduceB>

type ReduceC = ReduceC1<R0::ReduceC>

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

type Output = (O0, O1)

type Pipe = (R0::Pipe, R1::Pipe)

type ReduceAFactory = ReduceA2Factory<R0::ReduceAFactory, R1::ReduceAFactory>

type ReduceBFactory = ReduceC2Factory<R0::ReduceBFactory, R1::ReduceBFactory>

type ReduceA = ReduceA2<R0::ReduceA, R1::ReduceA>

type ReduceB = ReduceC2<R0::ReduceB, R1::ReduceB>

type ReduceC = ReduceC2<R0::ReduceC, R1::ReduceC>

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

type Output = (O0, O1, O2)

type Pipe = (R0::Pipe, R1::Pipe, R2::Pipe)

type ReduceAFactory = ReduceA3Factory<R0::ReduceAFactory, R1::ReduceAFactory, R2::ReduceAFactory>

type ReduceBFactory = ReduceC3Factory<R0::ReduceBFactory, R1::ReduceBFactory, R2::ReduceBFactory>

type ReduceA = ReduceA3<R0::ReduceA, R1::ReduceA, R2::ReduceA>

type ReduceB = ReduceC3<R0::ReduceB, R1::ReduceB, R2::ReduceB>

type ReduceC = ReduceC3<R0::ReduceC, R1::ReduceC, R2::ReduceC>

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

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

type Pipe = (R0::Pipe, R1::Pipe, R2::Pipe, R3::Pipe)

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

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

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

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

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

impl<Source, 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>, O0, O1, O2, O3, O4> DistributedSink<Source> for (R0, R1, R2, R3, R4) where
    Source: Copy, [src]

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

type Pipe = (R0::Pipe, R1::Pipe, R2::Pipe, R3::Pipe, R4::Pipe)

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

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

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

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

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

impl<Source, 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>, O0, O1, O2, O3, O4, O5> DistributedSink<Source> for (R0, R1, R2, R3, R4, R5) where
    Source: Copy, [src]

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

type Pipe = (R0::Pipe, R1::Pipe, R2::Pipe, R3::Pipe, R4::Pipe, R5::Pipe)

type ReduceAFactory = ReduceA6Factory<R0::ReduceAFactory, R1::ReduceAFactory, R2::ReduceAFactory, R3::ReduceAFactory, R4::ReduceAFactory, R5::ReduceAFactory>

type ReduceBFactory = ReduceC6Factory<R0::ReduceBFactory, R1::ReduceBFactory, R2::ReduceBFactory, R3::ReduceBFactory, R4::ReduceBFactory, R5::ReduceBFactory>

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

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

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

impl<Source, 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>, O0, O1, O2, O3, O4, O5, O6> DistributedSink<Source> for (R0, R1, R2, R3, R4, R5, R6) where
    Source: Copy, [src]

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

type Pipe = (R0::Pipe, R1::Pipe, R2::Pipe, R3::Pipe, R4::Pipe, R5::Pipe, R6::Pipe)

type ReduceAFactory = ReduceA7Factory<R0::ReduceAFactory, R1::ReduceAFactory, R2::ReduceAFactory, R3::ReduceAFactory, R4::ReduceAFactory, R5::ReduceAFactory, R6::ReduceAFactory>

type ReduceBFactory = ReduceC7Factory<R0::ReduceBFactory, R1::ReduceBFactory, R2::ReduceBFactory, R3::ReduceBFactory, R4::ReduceBFactory, R5::ReduceBFactory, R6::ReduceBFactory>

type ReduceA = ReduceA7<R0::ReduceA, R1::ReduceA, R2::ReduceA, R3::ReduceA, R4::ReduceA, R5::ReduceA, R6::ReduceA>

type ReduceB = ReduceC7<R0::ReduceB, R1::ReduceB, R2::ReduceB, R3::ReduceB, R4::ReduceB, R5::ReduceB, R6::ReduceB>

type ReduceC = ReduceC7<R0::ReduceC, R1::ReduceC, R2::ReduceC, R3::ReduceC, R4::ReduceC, R5::ReduceC, R6::ReduceC>

impl<Source, 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>, O0, O1, O2, O3, O4, O5, O6, O7> DistributedSink<Source> for (R0, R1, R2, R3, R4, R5, R6, R7) where
    Source: Copy, [src]

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

type Pipe = (R0::Pipe, R1::Pipe, R2::Pipe, R3::Pipe, R4::Pipe, R5::Pipe, R6::Pipe, R7::Pipe)

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

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

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

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

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

Loading content...

Implementors

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

type Output = bool

type Pipe = I

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

type ReduceBFactory = BoolAndReducerFactory

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

type ReduceB = BoolAndReducer

type ReduceC = BoolAndReducer

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

type Output = bool

type Pipe = I

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

type ReduceBFactory = BoolOrReducerFactory

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

type ReduceB = BoolOrReducer

type ReduceC = BoolOrReducer

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

type Output = ()

type Pipe = I

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

type ReduceBFactory = DefaultReducerFactory<Self::ReduceB>

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

type ReduceB = PushReducer<()>

type ReduceC = PushReducer<()>

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

type Output = T

type Pipe = I

type ReduceAFactory = T::ReduceAFactory

type ReduceBFactory = T::ReduceBFactory

type ReduceA = T::ReduceA

type ReduceB = T::ReduceB

type ReduceC = T::ReduceC

impl<I: ParallelPipe<Source>, Source> DistributedSink<Source> for Count<I>[src]

type Output = <Self::ReduceC as Reducer>::Output

type Pipe = I

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

type ReduceBFactory = FolderSyncReducerFactory<<Self::ReduceA as Reducer>::Output, SumFolder<usize>>

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

type ReduceB = FolderSyncReducer<<Self::ReduceA as Reducer>::Output, SumFolder<usize>>

type ReduceC = FolderSyncReducer<<Self::ReduceB as Reducer>::Output, SumFolder<usize>>

impl<I: ParallelPipe<Source>, Source> DistributedSink<Source> for Max<I> where
    I::Item: Ord + Send + 'static, [src]

type Output = <Self::ReduceC as Reducer>::Output

type Pipe = I

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

type ReduceBFactory = FolderSyncReducerFactory<<Self::ReduceA as Reducer>::Output, Max<I::Item>>

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

type ReduceB = FolderSyncReducer<<Self::ReduceA as Reducer>::Output, Max<I::Item>>

type ReduceC = FolderSyncReducer<<Self::ReduceB as Reducer>::Output, Max<I::Item>>

impl<I: ParallelPipe<Source>, Source> DistributedSink<Source> for Min<I> where
    I::Item: Ord + Send + 'static, [src]

type Output = <Self::ReduceC as Reducer>::Output

type Pipe = I

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

type ReduceBFactory = FolderSyncReducerFactory<<Self::ReduceA as Reducer>::Output, Min<I::Item>>

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

type ReduceB = FolderSyncReducer<<Self::ReduceA as Reducer>::Output, Min<I::Item>>

type ReduceC = FolderSyncReducer<<Self::ReduceB as Reducer>::Output, Min<I::Item>>

impl<I: ParallelPipe<Source>, Source> DistributedSink<Source> for MostFrequent<I> where
    I::Item: Clone + Hash + Eq + Send + 'static, [src]

type Output = <Self::ReduceC as Reducer>::Output

type Pipe = I

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

type ReduceBFactory = FolderSyncReducerFactory<<Self::ReduceA as Reducer>::Output, SumZeroFolder<Top<I::Item, usize>>>

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

type ReduceB = FolderSyncReducer<<Self::ReduceA as Reducer>::Output, SumZeroFolder<Top<I::Item, usize>>>

type ReduceC = FolderSyncReducer<<Self::ReduceB as Reducer>::Output, SumZeroFolder<Top<I::Item, usize>>>

impl<I: ParallelPipe<Source>, Source> DistributedSink<Source> for SampleUnstable<I> where
    I::Item: Send + 'static, [src]

type Output = <Self::ReduceC as Reducer>::Output

type Pipe = I

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

type ReduceBFactory = FolderSyncReducerFactory<<Self::ReduceA as Reducer>::Output, SumFolder<SASampleUnstable<I::Item>>>

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

type ReduceB = FolderSyncReducer<<Self::ReduceA as Reducer>::Output, SumFolder<SASampleUnstable<I::Item>>>

type ReduceC = FolderSyncReducer<<Self::ReduceB as Reducer>::Output, SumFolder<SASampleUnstable<I::Item>>>

impl<I: ParallelPipe<Source>, Source, B> DistributedSink<Source> for Sum<I, B> where
    B: Sum<I::Item> + Sum<B> + Send + 'static, [src]

type Output = <Self::ReduceC as Reducer>::Output

type Pipe = I

type ReduceAFactory = FolderSyncReducerFactory<I::Item, SumFolder<B>>

type ReduceBFactory = FolderSyncReducerFactory<<Self::ReduceA as Reducer>::Output, SumFolder<B>>

type ReduceA = FolderSyncReducer<I::Item, SumFolder<B>>

type ReduceB = FolderSyncReducer<<Self::ReduceA as Reducer>::Output, SumFolder<B>>

type ReduceC = FolderSyncReducer<<Self::ReduceB as Reducer>::Output, SumFolder<B>>

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

type Output = <Self::ReduceC as Reducer>::Output

type Pipe = I

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

type ReduceBFactory = FolderSyncReducerFactory<<Self::ReduceA as Reducer>::Output, ReduceFn<F, I::Item>>

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

type ReduceB = FolderSyncReducer<<Self::ReduceA as Reducer>::Output, ReduceFn<F, I::Item>>

type ReduceC = FolderSyncReducer<<Self::ReduceB as Reducer>::Output, ReduceFn<F, I::Item>>

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

type Output = <Self::ReduceC as Reducer>::Output

type Pipe = I

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

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

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

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

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

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

type Output = <Self::ReduceC as Reducer>::Output

type Pipe = I

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

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

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

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

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

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

type Output = <Self::ReduceC as Reducer>::Output

type Pipe = I

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

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

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

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

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

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

type Output = <Self::ReduceC as Reducer>::Output

type Pipe = I

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

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

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

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

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

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

type Output = <Self::ReduceC as Reducer>::Output

type Pipe = I

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

type ReduceBFactory = FolderSyncReducerFactory<<Self::ReduceA as Reducer>::Output, FoldFolder<I::Item, ID, F, B, StepB>>

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

type ReduceB = FolderSyncReducer<<Self::ReduceA as Reducer>::Output, FoldFolder<I::Item, ID, F, B, StepB>>

type ReduceC = FolderSyncReducer<<Self::ReduceB as Reducer>::Output, FoldFolder<I::Item, ID, F, B, StepB>>

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

type Output = <Self::ReduceC as Reducer>::Output

type Pipe = I

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

type ReduceBFactory = FolderSyncReducerFactory<<Self::ReduceA as Reducer>::Output, SumZeroFolder<Top<A, HyperLogLogMagnitude<B>>>>

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

type ReduceB = FolderSyncReducer<<Self::ReduceA as Reducer>::Output, SumZeroFolder<Top<A, HyperLogLogMagnitude<B>>>>

type ReduceC = FolderSyncReducer<<Self::ReduceB as Reducer>::Output, SumZeroFolder<Top<A, HyperLogLogMagnitude<B>>>>

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

type Output = <Self::ReduceC as Reducer>::Output

type Pipe = I

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

type ReduceBFactory = FolderSyncReducerFactory<<Self::ReduceA as Reducer>::Output, GroupByFolder<A, B, ID, F, C, StepB>>

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

type ReduceB = FolderSyncReducer<<Self::ReduceA as Reducer>::Output, GroupByFolder<A, B, ID, F, C, StepB>>

type ReduceC = FolderSyncReducer<<Self::ReduceB as Reducer>::Output, GroupByFolder<A, B, ID, F, C, StepB>>

Loading content...