[−][src]Trait amadeus::dist_iter::DistributedReducer

pub trait DistributedReducer<I, Source, B> where
    I: DistributedIteratorMulti<Source>,
    <Self::ReduceAFactory as ReduceFactory>::Reducer == Self::ReduceA,
    <Self::ReduceA as Reducer>::Item == <I as DistributedIteratorMulti<Source>>::Item,
    <Self::ReduceB as Reducer>::Item == <Self::ReduceA as Reducer>::Output,
    <Self::ReduceB as Reducer>::Output == B, {
    type ReduceAFactory: ReduceFactory;
    type ReduceA: ReducerA + ProcessSend;
    type ReduceB: Reducer;
    fn reducers(self) -> (I, Self::ReduceAFactory, Self::ReduceB);
}

Associated Types

`type ReduceAFactory: ReduceFactory`

`type ReduceA: ReducerA + ProcessSend`

`type ReduceB: Reducer`

Loading content...

Required methods

`fn reducers(self) -> (I, Self::ReduceAFactory, Self::ReduceB)`

Loading content...

Implementations on Foreign Types

`impl<I0, I1, Source, R0, R1, O0, O1> DistributedReducer<(I0, I1), Source, (O0, O1)> for (R0, R1) where I0: DistributedIteratorMulti<Source>, I1: DistributedIteratorMulti<Source>, R0: DistributedReducer<I0, Source, O0>, R1: DistributedReducer<I1, Source, O1>, Source: Copy,` [src]

`type ReduceAFactory = ReduceA2Factory<<R0 as DistributedReducer<I0, Source, O0>>::ReduceAFactory, <R1 as DistributedReducer<I1, Source, O1>>::ReduceAFactory>`

`type ReduceA = ReduceA2<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA, <R1 as DistributedReducer<I1, Source, O1>>::ReduceA>`

`type ReduceB = ReduceB2<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB, <R1 as DistributedReducer<I1, Source, O1>>::ReduceB>`

`fn reducers( self ) -> ((I0, I1), <(R0, R1) as DistributedReducer<(I0, I1), Source, (O0, O1)>>::ReduceAFactory, <(R0, R1) as DistributedReducer<(I0, I1), Source, (O0, O1)>>::ReduceB)`[src]

`impl<I0, I1, I2, Source, R0, R1, R2, O0, O1, O2> DistributedReducer<(I0, I1, I2), Source, (O0, O1, O2)> for (R0, R1, R2) where I0: DistributedIteratorMulti<Source>, I1: DistributedIteratorMulti<Source>, I2: DistributedIteratorMulti<Source>, R0: DistributedReducer<I0, Source, O0>, R1: DistributedReducer<I1, Source, O1>, R2: DistributedReducer<I2, Source, O2>, Source: Copy,` [src]

`type ReduceAFactory = ReduceA3Factory<<R0 as DistributedReducer<I0, Source, O0>>::ReduceAFactory, <R1 as DistributedReducer<I1, Source, O1>>::ReduceAFactory, <R2 as DistributedReducer<I2, Source, O2>>::ReduceAFactory>`

`type ReduceA = ReduceA3<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA, <R1 as DistributedReducer<I1, Source, O1>>::ReduceA, <R2 as DistributedReducer<I2, Source, O2>>::ReduceA>`

`type ReduceB = ReduceB3<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB, <R1 as DistributedReducer<I1, Source, O1>>::ReduceB, <R2 as DistributedReducer<I2, Source, O2>>::ReduceB>`

`fn reducers( self ) -> ((I0, I1, I2), <(R0, R1, R2) as DistributedReducer<(I0, I1, I2), Source, (O0, O1, O2)>>::ReduceAFactory, <(R0, R1, R2) as DistributedReducer<(I0, I1, I2), Source, (O0, O1, O2)>>::ReduceB)`[src]

`impl<I0, Source, R0, O0> DistributedReducer<(I0,), Source, (O0,)> for (R0,) where I0: DistributedIteratorMulti<Source>, R0: DistributedReducer<I0, Source, O0>,` [src]

`type ReduceAFactory = ReduceA1Factory<<R0 as DistributedReducer<I0, Source, O0>>::ReduceAFactory>`

`type ReduceA = ReduceA1<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA>`

`type ReduceB = ReduceB1<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB>`

`fn reducers( self ) -> ((I0,), <(R0,) as DistributedReducer<(I0,), Source, (O0,)>>::ReduceAFactory, <(R0,) as DistributedReducer<(I0,), Source, (O0,)>>::ReduceB)`[src]

impl<I0, I1, I2, I3, I4, I5, I6, Source, R0, R1, R2, R3, R4, R5, R6, O0, O1, O2, O3, O4, O5, O6> DistributedReducer<(I0, I1, I2, I3, I4, I5, I6), Source, (O0, O1, O2, O3, O4, O5, O6)> for (R0, R1, R2, R3, R4, R5, R6) where I0: DistributedIteratorMulti<Source>, I1: DistributedIteratorMulti<Source>, I2: DistributedIteratorMulti<Source>, I3: DistributedIteratorMulti<Source>, I4: DistributedIteratorMulti<Source>, I5: DistributedIteratorMulti<Source>, I6: DistributedIteratorMulti<Source>, R0: DistributedReducer<I0, Source, O0>, R1: DistributedReducer<I1, Source, O1>, R2: DistributedReducer<I2, Source, O2>, R3: DistributedReducer<I3, Source, O3>, R4: DistributedReducer<I4, Source, O4>, R5: DistributedReducer<I5, Source, O5>, R6: DistributedReducer<I6, Source, O6>, Source: Copy, [src]

`type ReduceAFactory = ReduceA7Factory<<R0 as DistributedReducer<I0, Source, O0>>::ReduceAFactory, <R1 as DistributedReducer<I1, Source, O1>>::ReduceAFactory, <R2 as DistributedReducer<I2, Source, O2>>::ReduceAFactory, <R3 as DistributedReducer<I3, Source, O3>>::ReduceAFactory, <R4 as DistributedReducer<I4, Source, O4>>::ReduceAFactory, <R5 as DistributedReducer<I5, Source, O5>>::ReduceAFactory, <R6 as DistributedReducer<I6, Source, O6>>::ReduceAFactory>`

`type ReduceA = ReduceA7<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA, <R1 as DistributedReducer<I1, Source, O1>>::ReduceA, <R2 as DistributedReducer<I2, Source, O2>>::ReduceA, <R3 as DistributedReducer<I3, Source, O3>>::ReduceA, <R4 as DistributedReducer<I4, Source, O4>>::ReduceA, <R5 as DistributedReducer<I5, Source, O5>>::ReduceA, <R6 as DistributedReducer<I6, Source, O6>>::ReduceA>`

`type ReduceB = ReduceB7<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB, <R1 as DistributedReducer<I1, Source, O1>>::ReduceB, <R2 as DistributedReducer<I2, Source, O2>>::ReduceB, <R3 as DistributedReducer<I3, Source, O3>>::ReduceB, <R4 as DistributedReducer<I4, Source, O4>>::ReduceB, <R5 as DistributedReducer<I5, Source, O5>>::ReduceB, <R6 as DistributedReducer<I6, Source, O6>>::ReduceB>`

`fn reducers( self ) -> ((I0, I1, I2, I3, I4, I5, I6), <(R0, R1, R2, R3, R4, R5, R6) as DistributedReducer<(I0, I1, I2, I3, I4, I5, I6), Source, (O0, O1, O2, O3, O4, O5, O6)>>::ReduceAFactory, <(R0, R1, R2, R3, R4, R5, R6) as DistributedReducer<(I0, I1, I2, I3, I4, I5, I6), Source, (O0, O1, O2, O3, O4, O5, O6)>>::ReduceB)`[src]

impl<I0, I1, I2, I3, I4, Source, R0, R1, R2, R3, R4, O0, O1, O2, O3, O4> DistributedReducer<(I0, I1, I2, I3, I4), Source, (O0, O1, O2, O3, O4)> for (R0, R1, R2, R3, R4) where I0: DistributedIteratorMulti<Source>, I1: DistributedIteratorMulti<Source>, I2: DistributedIteratorMulti<Source>, I3: DistributedIteratorMulti<Source>, I4: DistributedIteratorMulti<Source>, R0: DistributedReducer<I0, Source, O0>, R1: DistributedReducer<I1, Source, O1>, R2: DistributedReducer<I2, Source, O2>, R3: DistributedReducer<I3, Source, O3>, R4: DistributedReducer<I4, Source, O4>, Source: Copy, [src]

`type ReduceAFactory = ReduceA5Factory<<R0 as DistributedReducer<I0, Source, O0>>::ReduceAFactory, <R1 as DistributedReducer<I1, Source, O1>>::ReduceAFactory, <R2 as DistributedReducer<I2, Source, O2>>::ReduceAFactory, <R3 as DistributedReducer<I3, Source, O3>>::ReduceAFactory, <R4 as DistributedReducer<I4, Source, O4>>::ReduceAFactory>`

`type ReduceA = ReduceA5<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA, <R1 as DistributedReducer<I1, Source, O1>>::ReduceA, <R2 as DistributedReducer<I2, Source, O2>>::ReduceA, <R3 as DistributedReducer<I3, Source, O3>>::ReduceA, <R4 as DistributedReducer<I4, Source, O4>>::ReduceA>`

`type ReduceB = ReduceB5<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB, <R1 as DistributedReducer<I1, Source, O1>>::ReduceB, <R2 as DistributedReducer<I2, Source, O2>>::ReduceB, <R3 as DistributedReducer<I3, Source, O3>>::ReduceB, <R4 as DistributedReducer<I4, Source, O4>>::ReduceB>`

`fn reducers( self ) -> ((I0, I1, I2, I3, I4), <(R0, R1, R2, R3, R4) as DistributedReducer<(I0, I1, I2, I3, I4), Source, (O0, O1, O2, O3, O4)>>::ReduceAFactory, <(R0, R1, R2, R3, R4) as DistributedReducer<(I0, I1, I2, I3, I4), Source, (O0, O1, O2, O3, O4)>>::ReduceB)`[src]

impl<I0, I1, I2, I3, I4, I5, Source, R0, R1, R2, R3, R4, R5, O0, O1, O2, O3, O4, O5> DistributedReducer<(I0, I1, I2, I3, I4, I5), Source, (O0, O1, O2, O3, O4, O5)> for (R0, R1, R2, R3, R4, R5) where I0: DistributedIteratorMulti<Source>, I1: DistributedIteratorMulti<Source>, I2: DistributedIteratorMulti<Source>, I3: DistributedIteratorMulti<Source>, I4: DistributedIteratorMulti<Source>, I5: DistributedIteratorMulti<Source>, R0: DistributedReducer<I0, Source, O0>, R1: DistributedReducer<I1, Source, O1>, R2: DistributedReducer<I2, Source, O2>, R3: DistributedReducer<I3, Source, O3>, R4: DistributedReducer<I4, Source, O4>, R5: DistributedReducer<I5, Source, O5>, Source: Copy, [src]

`type ReduceAFactory = ReduceA6Factory<<R0 as DistributedReducer<I0, Source, O0>>::ReduceAFactory, <R1 as DistributedReducer<I1, Source, O1>>::ReduceAFactory, <R2 as DistributedReducer<I2, Source, O2>>::ReduceAFactory, <R3 as DistributedReducer<I3, Source, O3>>::ReduceAFactory, <R4 as DistributedReducer<I4, Source, O4>>::ReduceAFactory, <R5 as DistributedReducer<I5, Source, O5>>::ReduceAFactory>`

`type ReduceA = ReduceA6<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA, <R1 as DistributedReducer<I1, Source, O1>>::ReduceA, <R2 as DistributedReducer<I2, Source, O2>>::ReduceA, <R3 as DistributedReducer<I3, Source, O3>>::ReduceA, <R4 as DistributedReducer<I4, Source, O4>>::ReduceA, <R5 as DistributedReducer<I5, Source, O5>>::ReduceA>`

`type ReduceB = ReduceB6<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB, <R1 as DistributedReducer<I1, Source, O1>>::ReduceB, <R2 as DistributedReducer<I2, Source, O2>>::ReduceB, <R3 as DistributedReducer<I3, Source, O3>>::ReduceB, <R4 as DistributedReducer<I4, Source, O4>>::ReduceB, <R5 as DistributedReducer<I5, Source, O5>>::ReduceB>`

`fn reducers( self ) -> ((I0, I1, I2, I3, I4, I5), <(R0, R1, R2, R3, R4, R5) as DistributedReducer<(I0, I1, I2, I3, I4, I5), Source, (O0, O1, O2, O3, O4, O5)>>::ReduceAFactory, <(R0, R1, R2, R3, R4, R5) as DistributedReducer<(I0, I1, I2, I3, I4, I5), Source, (O0, O1, O2, O3, O4, O5)>>::ReduceB)`[src]

impl<I0, I1, I2, I3, Source, R0, R1, R2, R3, O0, O1, O2, O3> DistributedReducer<(I0, I1, I2, I3), Source, (O0, O1, O2, O3)> for (R0, R1, R2, R3) where I0: DistributedIteratorMulti<Source>, I1: DistributedIteratorMulti<Source>, I2: DistributedIteratorMulti<Source>, I3: DistributedIteratorMulti<Source>, R0: DistributedReducer<I0, Source, O0>, R1: DistributedReducer<I1, Source, O1>, R2: DistributedReducer<I2, Source, O2>, R3: DistributedReducer<I3, Source, O3>, Source: Copy, [src]

`type ReduceAFactory = ReduceA4Factory<<R0 as DistributedReducer<I0, Source, O0>>::ReduceAFactory, <R1 as DistributedReducer<I1, Source, O1>>::ReduceAFactory, <R2 as DistributedReducer<I2, Source, O2>>::ReduceAFactory, <R3 as DistributedReducer<I3, Source, O3>>::ReduceAFactory>`

`type ReduceA = ReduceA4<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA, <R1 as DistributedReducer<I1, Source, O1>>::ReduceA, <R2 as DistributedReducer<I2, Source, O2>>::ReduceA, <R3 as DistributedReducer<I3, Source, O3>>::ReduceA>`

`type ReduceB = ReduceB4<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB, <R1 as DistributedReducer<I1, Source, O1>>::ReduceB, <R2 as DistributedReducer<I2, Source, O2>>::ReduceB, <R3 as DistributedReducer<I3, Source, O3>>::ReduceB>`

`fn reducers( self ) -> ((I0, I1, I2, I3), <(R0, R1, R2, R3) as DistributedReducer<(I0, I1, I2, I3), Source, (O0, O1, O2, O3)>>::ReduceAFactory, <(R0, R1, R2, R3) as DistributedReducer<(I0, I1, I2, I3), Source, (O0, O1, O2, O3)>>::ReduceB)`[src]

impl<I0, I1, I2, I3, I4, I5, I6, I7, Source, R0, R1, R2, R3, R4, R5, R6, R7, O0, O1, O2, O3, O4, O5, O6, O7> DistributedReducer<(I0, I1, I2, I3, I4, I5, I6, I7), Source, (O0, O1, O2, O3, O4, O5, O6, O7)> for (R0, R1, R2, R3, R4, R5, R6, R7) where I0: DistributedIteratorMulti<Source>, I1: DistributedIteratorMulti<Source>, I2: DistributedIteratorMulti<Source>, I3: DistributedIteratorMulti<Source>, I4: DistributedIteratorMulti<Source>, I5: DistributedIteratorMulti<Source>, I6: DistributedIteratorMulti<Source>, I7: DistributedIteratorMulti<Source>, R0: DistributedReducer<I0, Source, O0>, R1: DistributedReducer<I1, Source, O1>, R2: DistributedReducer<I2, Source, O2>, R3: DistributedReducer<I3, Source, O3>, R4: DistributedReducer<I4, Source, O4>, R5: DistributedReducer<I5, Source, O5>, R6: DistributedReducer<I6, Source, O6>, R7: DistributedReducer<I7, Source, O7>, Source: Copy, [src]

type ReduceAFactory = ReduceA8Factory<<R0 as DistributedReducer<I0, Source, O0>>::ReduceAFactory, <R1 as DistributedReducer<I1, Source, O1>>::ReduceAFactory, <R2 as DistributedReducer<I2, Source, O2>>::ReduceAFactory, <R3 as DistributedReducer<I3, Source, O3>>::ReduceAFactory, <R4 as DistributedReducer<I4, Source, O4>>::ReduceAFactory, <R5 as DistributedReducer<I5, Source, O5>>::ReduceAFactory, <R6 as DistributedReducer<I6, Source, O6>>::ReduceAFactory, <R7 as DistributedReducer<I7, Source, O7>>::ReduceAFactory>

`type ReduceA = ReduceA8<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA, <R1 as DistributedReducer<I1, Source, O1>>::ReduceA, <R2 as DistributedReducer<I2, Source, O2>>::ReduceA, <R3 as DistributedReducer<I3, Source, O3>>::ReduceA, <R4 as DistributedReducer<I4, Source, O4>>::ReduceA, <R5 as DistributedReducer<I5, Source, O5>>::ReduceA, <R6 as DistributedReducer<I6, Source, O6>>::ReduceA, <R7 as DistributedReducer<I7, Source, O7>>::ReduceA>`

`type ReduceB = ReduceB8<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB, <R1 as DistributedReducer<I1, Source, O1>>::ReduceB, <R2 as DistributedReducer<I2, Source, O2>>::ReduceB, <R3 as DistributedReducer<I3, Source, O3>>::ReduceB, <R4 as DistributedReducer<I4, Source, O4>>::ReduceB, <R5 as DistributedReducer<I5, Source, O5>>::ReduceB, <R6 as DistributedReducer<I6, Source, O6>>::ReduceB, <R7 as DistributedReducer<I7, Source, O7>>::ReduceB>`

`fn reducers( self ) -> ((I0, I1, I2, I3, I4, I5, I6, I7), <(R0, R1, R2, R3, R4, R5, R6, R7) as DistributedReducer<(I0, I1, I2, I3, I4, I5, I6, I7), Source, (O0, O1, O2, O3, O4, O5, O6, O7)>>::ReduceAFactory, <(R0, R1, R2, R3, R4, R5, R6, R7) as DistributedReducer<(I0, I1, I2, I3, I4, I5, I6, I7), Source, (O0, O1, O2, O3, O4, O5, O6, O7)>>::ReduceB)`[src]

`impl<Source> DistributedReducer<(), Source, ()> for ()`[src]

`type ReduceAFactory = ReduceA0Factory`

`type ReduceA = ReduceA0`

`type ReduceB = ReduceB0`

`fn reducers( self ) -> ((), <() as DistributedReducer<(), Source, ()>>::ReduceAFactory, <() as DistributedReducer<(), Source, ()>>::ReduceB)`[src]

Loading content...

Implementors

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

`type ReduceAFactory = SumReducerFactory<>::Item, B>`

`type ReduceA = SumReducer<>::Item, B>`

`type ReduceB = SumReducer<B, B>`

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

`impl<I, Source> DistributedReducer<I, Source, Option<>::Item>> for Max where I: DistributedIteratorMulti<Source>, >::Item: Ord, >::Item: ProcessSend,` [src]

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

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

`type ReduceB = CombineReducer<Option<>::Item>, >::Item, Max>`

`fn reducers( self ) -> (I, <Max as DistributedReducer<I, Source, Option<>::Item>>>::ReduceAFactory, <Max as DistributedReducer<I, Source, Option<>::Item>>>::ReduceB)`[src]

`impl<I, Source> DistributedReducer<I, Source, Option<>::Item>> for Min where I: DistributedIteratorMulti<Source>, >::Item: Ord, >::Item: ProcessSend,` [src]

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

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

`type ReduceB = CombineReducer<Option<>::Item>, >::Item, Min>`

`fn reducers( self ) -> (I, <Min as DistributedReducer<I, Source, Option<>::Item>>>::ReduceAFactory, <Min as DistributedReducer<I, Source, Option<>::Item>>>::ReduceB)`[src]

`impl<I, Source> DistributedReducer<I, Source, usize> for Count where I: DistributedIteratorMulti<Source>, >::Item: 'static,` [src]

`type ReduceAFactory = CountReducerFactory<>::Item>`

`type ReduceA = CountReducer<>::Item>`

`type ReduceB = SumReducer<usize, usize>`

`fn reducers( self ) -> (I, <Count as DistributedReducer<I, Source, usize>>::ReduceAFactory, <Count as DistributedReducer<I, Source, usize>>::ReduceB)`[src]

`impl<I, Source> DistributedReducer<I, Source, SampleUnstable<>::Item>> for SampleUnstable where I: DistributedIteratorMulti<Source>, >::Item: ProcessSend,` [src]

`type ReduceAFactory = SampleUnstableReducerFactory<>::Item>`

`type ReduceA = SampleUnstableReducer<>::Item>`

`type ReduceB = SumReducer<SampleUnstable<>::Item>, SampleUnstable<>::Item>>`

`fn reducers( self ) -> (I, <SampleUnstable as DistributedReducer<I, Source, SampleUnstable<>::Item>>>::ReduceAFactory, <SampleUnstable as DistributedReducer<I, Source, SampleUnstable<>::Item>>>::ReduceB)`[src]

`impl<I, Source> DistributedReducer<I, Source, Top<>::Item, usize>> for MostFrequent where I: DistributedIteratorMulti<Source>, >::Item: Clone, >::Item: Hash, >::Item: Eq, >::Item: ProcessSend,` [src]

`type ReduceAFactory = MostFrequentReducerFactory<>::Item>`

`type ReduceA = MostFrequentReducer<>::Item>`

`type ReduceB = NonzeroReducer<SumReducer<Top<>::Item, usize>, Zeroable<Top<>::Item, usize>>>>`

`fn reducers( self ) -> (I, <MostFrequent as DistributedReducer<I, Source, Top<>::Item, usize>>>::ReduceAFactory, <MostFrequent as DistributedReducer<I, Source, Top<>::Item, usize>>>::ReduceB)`[src]

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

`type ReduceAFactory = MostDistinctReducerFactory<A, B>`

`type ReduceA = MostDistinctReducer<A, B>`

`type ReduceB = NonzeroReducer<SumReducer<Top<A, HyperLogLogMagnitude>, Zeroable<Top<A, HyperLogLogMagnitude>>>>`

`fn reducers( self ) -> (I, <MostDistinct as DistributedReducer<I, Source, Top<A, HyperLogLogMagnitude>>>::ReduceAFactory, <MostDistinct as DistributedReducer<I, Source, Top<A, HyperLogLogMagnitude>>>::ReduceB)`[src]

`impl<I, Source, F> DistributedReducer<I, Source, Option<>::Item>> for Combine<I, F> where F: FnMut(>::Item, >::Item) -> >::Item + Clone + ProcessSend, I: DistributedIteratorMulti<Source>, >::Item: ProcessSend,` [src]

`type ReduceAFactory = CombineReducerFactory<>::Item, >::Item, CombineFn<F>>`

`type ReduceA = CombineReducer<>::Item, >::Item, CombineFn<F>>`

`type ReduceB = CombineReducer<Option<>::Item>, >::Item, CombineFn<F>>`

`fn reducers( self ) -> (I, <Combine<I, F> as DistributedReducer<I, Source, Option<>::Item>>>::ReduceAFactory, <Combine<I, F> as DistributedReducer<I, Source, Option<>::Item>>>::ReduceB)`[src]

`impl<I, Source, F> DistributedReducer<I, Source, Option<>::Item>> for MaxBy<I, F> where F: FnMut(&>::Item, &>::Item) -> Ordering + Clone + ProcessSend, I: DistributedIteratorMulti<Source>, >::Item: ProcessSend,` [src]

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

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

`type ReduceB = CombineReducer<Option<>::Item>, >::Item, MaxBy<F>>`

`fn reducers( self ) -> (I, <MaxBy<I, F> as DistributedReducer<I, Source, Option<>::Item>>>::ReduceAFactory, <MaxBy<I, F> as DistributedReducer<I, Source, Option<>::Item>>>::ReduceB)`[src]

`impl<I, Source, F> DistributedReducer<I, Source, Option<>::Item>> for MinBy<I, F> where F: FnMut(&>::Item, &>::Item) -> Ordering + Clone + ProcessSend, I: DistributedIteratorMulti<Source>, >::Item: ProcessSend,` [src]

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

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

`type ReduceB = CombineReducer<Option<>::Item>, >::Item, MinBy<F>>`

`fn reducers( self ) -> (I, <MinBy<I, F> as DistributedReducer<I, Source, Option<>::Item>>>::ReduceAFactory, <MinBy<I, F> as DistributedReducer<I, Source, Option<>::Item>>>::ReduceB)`[src]

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

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

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

`type ReduceB = BoolAndReducer`

`fn reducers( self ) -> (I, <All<I, F> as DistributedReducer<I, Source, bool>>::ReduceAFactory, <All<I, F> as DistributedReducer<I, Source, bool>>::ReduceB)`[src]

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

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

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

`type ReduceB = BoolOrReducer`

`fn reducers( self ) -> (I, <Any<I, F> as DistributedReducer<I, Source, bool>>::ReduceAFactory, <Any<I, F> as DistributedReducer<I, Source, bool>>::ReduceB)`[src]

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

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

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

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

`fn reducers( self ) -> (I, <ForEach<I, F> as DistributedReducer<I, Source, ()>>::ReduceAFactory, <ForEach<I, F> as DistributedReducer<I, Source, ()>>::ReduceB)`[src]

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

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

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

`type ReduceB = CombineReducer<Option<>::Item>, >::Item, MaxByKey<F, B>>`

`fn reducers( self ) -> (I, <MaxByKey<I, F> as DistributedReducer<I, Source, Option<>::Item>>>::ReduceAFactory, <MaxByKey<I, F> as DistributedReducer<I, Source, Option<>::Item>>>::ReduceB)`[src]

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

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

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

`type ReduceB = CombineReducer<Option<>::Item>, >::Item, MinByKey<F, B>>`

`fn reducers( self ) -> (I, <MinByKey<I, F> as DistributedReducer<I, Source, Option<>::Item>>>::ReduceAFactory, <MinByKey<I, F> as DistributedReducer<I, Source, Option<>::Item>>>::ReduceB)`[src]

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

`type ReduceAFactory = FoldReducerFactory<>::Item, ID, F, B>`

`type ReduceA = FoldReducerA<>::Item, ID, F, B>`

`type ReduceB = FoldReducerB<>::Item, ID, F, B>`

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

`impl<I, Source, T> DistributedReducer<I, Source, T> for Collect<I, T> where I: DistributedIteratorMulti<Source>, T: FromDistributedIterator<>::Item>,` [src]

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

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

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

`fn reducers( self ) -> (I, <Collect<I, T> as DistributedReducer<I, Source, T>>::ReduceAFactory, <Collect<I, T> as DistributedReducer<I, Source, T>>::ReduceB)`[src]

Loading content...

[−][src]Trait amadeus::dist_iter::DistributedReducer

Associated Types

type ReduceAFactory: ReduceFactory

type ReduceA: ReducerA + ProcessSend

type ReduceB: Reducer

Required methods

fn reducers(self) -> (I, Self::ReduceAFactory, Self::ReduceB)

Implementations on Foreign Types

impl<I0, I1, Source, R0, R1, O0, O1> DistributedReducer<(I0, I1), Source, (O0, O1)> for (R0, R1) where I0: DistributedIteratorMulti<Source>, I1: DistributedIteratorMulti<Source>, R0: DistributedReducer<I0, Source, O0>, R1: DistributedReducer<I1, Source, O1>, Source: Copy, [src]

type ReduceAFactory = ReduceA2Factory<<R0 as DistributedReducer<I0, Source, O0>>::ReduceAFactory, <R1 as DistributedReducer<I1, Source, O1>>::ReduceAFactory>

type ReduceA = ReduceA2<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA, <R1 as DistributedReducer<I1, Source, O1>>::ReduceA>

type ReduceB = ReduceB2<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB, <R1 as DistributedReducer<I1, Source, O1>>::ReduceB>

fn reducers( self) -> ((I0, I1), <(R0, R1) as DistributedReducer<(I0, I1), Source, (O0, O1)>>::ReduceAFactory, <(R0, R1) as DistributedReducer<(I0, I1), Source, (O0, O1)>>::ReduceB)[src]

type ReduceAFactory = ReduceA3Factory<<R0 as DistributedReducer<I0, Source, O0>>::ReduceAFactory, <R1 as DistributedReducer<I1, Source, O1>>::ReduceAFactory, <R2 as DistributedReducer<I2, Source, O2>>::ReduceAFactory>

type ReduceA = ReduceA3<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA, <R1 as DistributedReducer<I1, Source, O1>>::ReduceA, <R2 as DistributedReducer<I2, Source, O2>>::ReduceA>

type ReduceB = ReduceB3<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB, <R1 as DistributedReducer<I1, Source, O1>>::ReduceB, <R2 as DistributedReducer<I2, Source, O2>>::ReduceB>

fn reducers( self) -> ((I0, I1, I2), <(R0, R1, R2) as DistributedReducer<(I0, I1, I2), Source, (O0, O1, O2)>>::ReduceAFactory, <(R0, R1, R2) as DistributedReducer<(I0, I1, I2), Source, (O0, O1, O2)>>::ReduceB)[src]

impl<I0, Source, R0, O0> DistributedReducer<(I0,), Source, (O0,)> for (R0,) where I0: DistributedIteratorMulti<Source>, R0: DistributedReducer<I0, Source, O0>, [src]

type ReduceAFactory = ReduceA1Factory<<R0 as DistributedReducer<I0, Source, O0>>::ReduceAFactory>

type ReduceA = ReduceA1<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA>

type ReduceB = ReduceB1<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB>

fn reducers( self) -> ((I0,), <(R0,) as DistributedReducer<(I0,), Source, (O0,)>>::ReduceAFactory, <(R0,) as DistributedReducer<(I0,), Source, (O0,)>>::ReduceB)[src]

type ReduceA = ReduceA5<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA, <R1 as DistributedReducer<I1, Source, O1>>::ReduceA, <R2 as DistributedReducer<I2, Source, O2>>::ReduceA, <R3 as DistributedReducer<I3, Source, O3>>::ReduceA, <R4 as DistributedReducer<I4, Source, O4>>::ReduceA>

type ReduceB = ReduceB5<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB, <R1 as DistributedReducer<I1, Source, O1>>::ReduceB, <R2 as DistributedReducer<I2, Source, O2>>::ReduceB, <R3 as DistributedReducer<I3, Source, O3>>::ReduceB, <R4 as DistributedReducer<I4, Source, O4>>::ReduceB>

fn reducers( self) -> ((I0, I1, I2, I3, I4), <(R0, R1, R2, R3, R4) as DistributedReducer<(I0, I1, I2, I3, I4), Source, (O0, O1, O2, O3, O4)>>::ReduceAFactory, <(R0, R1, R2, R3, R4) as DistributedReducer<(I0, I1, I2, I3, I4), Source, (O0, O1, O2, O3, O4)>>::ReduceB)[src]

fn reducers( self) -> ((I0, I1, I2, I3, I4, I5), <(R0, R1, R2, R3, R4, R5) as DistributedReducer<(I0, I1, I2, I3, I4, I5), Source, (O0, O1, O2, O3, O4, O5)>>::ReduceAFactory, <(R0, R1, R2, R3, R4, R5) as DistributedReducer<(I0, I1, I2, I3, I4, I5), Source, (O0, O1, O2, O3, O4, O5)>>::ReduceB)[src]

type ReduceAFactory = ReduceA4Factory<<R0 as DistributedReducer<I0, Source, O0>>::ReduceAFactory, <R1 as DistributedReducer<I1, Source, O1>>::ReduceAFactory, <R2 as DistributedReducer<I2, Source, O2>>::ReduceAFactory, <R3 as DistributedReducer<I3, Source, O3>>::ReduceAFactory>

type ReduceA = ReduceA4<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA, <R1 as DistributedReducer<I1, Source, O1>>::ReduceA, <R2 as DistributedReducer<I2, Source, O2>>::ReduceA, <R3 as DistributedReducer<I3, Source, O3>>::ReduceA>

type ReduceB = ReduceB4<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB, <R1 as DistributedReducer<I1, Source, O1>>::ReduceB, <R2 as DistributedReducer<I2, Source, O2>>::ReduceB, <R3 as DistributedReducer<I3, Source, O3>>::ReduceB>

fn reducers( self) -> ((I0, I1, I2, I3), <(R0, R1, R2, R3) as DistributedReducer<(I0, I1, I2, I3), Source, (O0, O1, O2, O3)>>::ReduceAFactory, <(R0, R1, R2, R3) as DistributedReducer<(I0, I1, I2, I3), Source, (O0, O1, O2, O3)>>::ReduceB)[src]

impl<Source> DistributedReducer<(), Source, ()> for ()[src]

type ReduceAFactory = ReduceA0Factory

type ReduceA = ReduceA0

type ReduceB = ReduceB0

fn reducers( self) -> ((), <() as DistributedReducer<(), Source, ()>>::ReduceAFactory, <() as DistributedReducer<(), Source, ()>>::ReduceB)[src]

Implementors

impl<I, B, Source> DistributedReducer<I, Source, B> for Sum<I, B> where B: Sum<<I as DistributedIteratorMulti<Source>>::Item> + Sum<B> + ProcessSend, I: DistributedIteratorMulti<Source>, <I as DistributedIteratorMulti<Source>>::Item: 'static, [src]

type ReduceAFactory = SumReducerFactory<<I as DistributedIteratorMulti<Source>>::Item, B>

type ReduceA = SumReducer<<I as DistributedIteratorMulti<Source>>::Item, B>

type ReduceB = SumReducer<B, B>

fn reducers( self) -> (I, <Sum<I, B> as DistributedReducer<I, Source, B>>::ReduceAFactory, <Sum<I, B> as DistributedReducer<I, Source, B>>::ReduceB)[src]

impl<I, Source> DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>> for Max<I> where I: DistributedIteratorMulti<Source>, <I as DistributedIteratorMulti<Source>>::Item: Ord, <I as DistributedIteratorMulti<Source>>::Item: ProcessSend, [src]

type ReduceAFactory = CombineReducerFactory<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, Max>

type ReduceA = CombineReducer<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, Max>

type ReduceB = CombineReducer<Option<<I as DistributedIteratorMulti<Source>>::Item>, <I as DistributedIteratorMulti<Source>>::Item, Max>

fn reducers( self) -> (I, <Max<I> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceAFactory, <Max<I> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceB)[src]

impl<I, Source> DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>> for Min<I> where I: DistributedIteratorMulti<Source>, <I as DistributedIteratorMulti<Source>>::Item: Ord, <I as DistributedIteratorMulti<Source>>::Item: ProcessSend, [src]

type ReduceAFactory = CombineReducerFactory<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, Min>

type ReduceA = CombineReducer<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, Min>

type ReduceB = CombineReducer<Option<<I as DistributedIteratorMulti<Source>>::Item>, <I as DistributedIteratorMulti<Source>>::Item, Min>

fn reducers( self) -> (I, <Min<I> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceAFactory, <Min<I> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceB)[src]

impl<I, Source> DistributedReducer<I, Source, usize> for Count<I> where I: DistributedIteratorMulti<Source>, <I as DistributedIteratorMulti<Source>>::Item: 'static, [src]

type ReduceAFactory = CountReducerFactory<<I as DistributedIteratorMulti<Source>>::Item>

type ReduceA = CountReducer<<I as DistributedIteratorMulti<Source>>::Item>

type ReduceB = SumReducer<usize, usize>

fn reducers( self) -> (I, <Count<I> as DistributedReducer<I, Source, usize>>::ReduceAFactory, <Count<I> as DistributedReducer<I, Source, usize>>::ReduceB)[src]

impl<I, Source> DistributedReducer<I, Source, SampleUnstable<<I as DistributedIteratorMulti<Source>>::Item>> for SampleUnstable<I> where I: DistributedIteratorMulti<Source>, <I as DistributedIteratorMulti<Source>>::Item: ProcessSend, [src]

type ReduceAFactory = SampleUnstableReducerFactory<<I as DistributedIteratorMulti<Source>>::Item>

type ReduceA = SampleUnstableReducer<<I as DistributedIteratorMulti<Source>>::Item>

type ReduceB = SumReducer<SampleUnstable<<I as DistributedIteratorMulti<Source>>::Item>, SampleUnstable<<I as DistributedIteratorMulti<Source>>::Item>>

fn reducers( self) -> (I, <SampleUnstable<I> as DistributedReducer<I, Source, SampleUnstable<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceAFactory, <SampleUnstable<I> as DistributedReducer<I, Source, SampleUnstable<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceB)[src]

type ReduceAFactory = MostFrequentReducerFactory<<I as DistributedIteratorMulti<Source>>::Item>

type ReduceA = MostFrequentReducer<<I as DistributedIteratorMulti<Source>>::Item>

type ReduceB = NonzeroReducer<SumReducer<Top<<I as DistributedIteratorMulti<Source>>::Item, usize>, Zeroable<Top<<I as DistributedIteratorMulti<Source>>::Item, usize>>>>

fn reducers( self) -> (I, <MostFrequent<I> as DistributedReducer<I, Source, Top<<I as DistributedIteratorMulti<Source>>::Item, usize>>>::ReduceAFactory, <MostFrequent<I> as DistributedReducer<I, Source, Top<<I as DistributedIteratorMulti<Source>>::Item, usize>>>::ReduceB)[src]

impl<I, Source, A, B> DistributedReducer<I, Source, Top<A, HyperLogLogMagnitude<B>>> for MostDistinct<I> where A: Clone + Hash + Eq + ProcessSend, B: Hash + 'static, I: DistributedIteratorMulti<Source, Item = (A, B)>, [src]

type ReduceAFactory = MostDistinctReducerFactory<A, B>

type ReduceA = MostDistinctReducer<A, B>

type ReduceB = NonzeroReducer<SumReducer<Top<A, HyperLogLogMagnitude<B>>, Zeroable<Top<A, HyperLogLogMagnitude<B>>>>>

fn reducers( self) -> (I, <MostDistinct<I> as DistributedReducer<I, Source, Top<A, HyperLogLogMagnitude<B>>>>::ReduceAFactory, <MostDistinct<I> as DistributedReducer<I, Source, Top<A, HyperLogLogMagnitude<B>>>>::ReduceB)[src]

type ReduceAFactory = CombineReducerFactory<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, CombineFn<F>>

type ReduceA = CombineReducer<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, CombineFn<F>>

type ReduceB = CombineReducer<Option<<I as DistributedIteratorMulti<Source>>::Item>, <I as DistributedIteratorMulti<Source>>::Item, CombineFn<F>>

fn reducers( self) -> (I, <Combine<I, F> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceAFactory, <Combine<I, F> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceB)[src]

type ReduceAFactory = CombineReducerFactory<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, MaxBy<F>>

type ReduceA = CombineReducer<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, MaxBy<F>>

type ReduceB = CombineReducer<Option<<I as DistributedIteratorMulti<Source>>::Item>, <I as DistributedIteratorMulti<Source>>::Item, MaxBy<F>>

fn reducers( self) -> (I, <MaxBy<I, F> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceAFactory, <MaxBy<I, F> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceB)[src]

type ReduceAFactory = CombineReducerFactory<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, MinBy<F>>

type ReduceA = CombineReducer<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, MinBy<F>>

`type ReduceAFactory: ReduceFactory`

`type ReduceA: ReducerA + ProcessSend`

`type ReduceB: Reducer`

`fn reducers(self) -> (I, Self::ReduceAFactory, Self::ReduceB)`

`impl<I0, I1, Source, R0, R1, O0, O1> DistributedReducer<(I0, I1), Source, (O0, O1)> for (R0, R1) where I0: DistributedIteratorMulti<Source>, I1: DistributedIteratorMulti<Source>, R0: DistributedReducer<I0, Source, O0>, R1: DistributedReducer<I1, Source, O1>, Source: Copy,` [src]

`type ReduceAFactory = ReduceA2Factory<<R0 as DistributedReducer<I0, Source, O0>>::ReduceAFactory, <R1 as DistributedReducer<I1, Source, O1>>::ReduceAFactory>`

`type ReduceA = ReduceA2<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA, <R1 as DistributedReducer<I1, Source, O1>>::ReduceA>`

`type ReduceB = ReduceB2<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB, <R1 as DistributedReducer<I1, Source, O1>>::ReduceB>`

`fn reducers( self ) -> ((I0, I1), <(R0, R1) as DistributedReducer<(I0, I1), Source, (O0, O1)>>::ReduceAFactory, <(R0, R1) as DistributedReducer<(I0, I1), Source, (O0, O1)>>::ReduceB)`[src]

`type ReduceAFactory = ReduceA3Factory<<R0 as DistributedReducer<I0, Source, O0>>::ReduceAFactory, <R1 as DistributedReducer<I1, Source, O1>>::ReduceAFactory, <R2 as DistributedReducer<I2, Source, O2>>::ReduceAFactory>`

`type ReduceA = ReduceA3<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA, <R1 as DistributedReducer<I1, Source, O1>>::ReduceA, <R2 as DistributedReducer<I2, Source, O2>>::ReduceA>`

`type ReduceB = ReduceB3<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB, <R1 as DistributedReducer<I1, Source, O1>>::ReduceB, <R2 as DistributedReducer<I2, Source, O2>>::ReduceB>`

`fn reducers( self ) -> ((I0, I1, I2), <(R0, R1, R2) as DistributedReducer<(I0, I1, I2), Source, (O0, O1, O2)>>::ReduceAFactory, <(R0, R1, R2) as DistributedReducer<(I0, I1, I2), Source, (O0, O1, O2)>>::ReduceB)`[src]

`impl<I0, Source, R0, O0> DistributedReducer<(I0,), Source, (O0,)> for (R0,) where I0: DistributedIteratorMulti<Source>, R0: DistributedReducer<I0, Source, O0>,` [src]

`type ReduceAFactory = ReduceA1Factory<<R0 as DistributedReducer<I0, Source, O0>>::ReduceAFactory>`

`type ReduceA = ReduceA1<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA>`

`type ReduceB = ReduceB1<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB>`

`fn reducers( self ) -> ((I0,), <(R0,) as DistributedReducer<(I0,), Source, (O0,)>>::ReduceAFactory, <(R0,) as DistributedReducer<(I0,), Source, (O0,)>>::ReduceB)`[src]

`type ReduceA = ReduceA5<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA, <R1 as DistributedReducer<I1, Source, O1>>::ReduceA, <R2 as DistributedReducer<I2, Source, O2>>::ReduceA, <R3 as DistributedReducer<I3, Source, O3>>::ReduceA, <R4 as DistributedReducer<I4, Source, O4>>::ReduceA>`

`type ReduceB = ReduceB5<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB, <R1 as DistributedReducer<I1, Source, O1>>::ReduceB, <R2 as DistributedReducer<I2, Source, O2>>::ReduceB, <R3 as DistributedReducer<I3, Source, O3>>::ReduceB, <R4 as DistributedReducer<I4, Source, O4>>::ReduceB>`

`fn reducers( self ) -> ((I0, I1, I2, I3, I4), <(R0, R1, R2, R3, R4) as DistributedReducer<(I0, I1, I2, I3, I4), Source, (O0, O1, O2, O3, O4)>>::ReduceAFactory, <(R0, R1, R2, R3, R4) as DistributedReducer<(I0, I1, I2, I3, I4), Source, (O0, O1, O2, O3, O4)>>::ReduceB)`[src]

`type ReduceAFactory = ReduceA4Factory<<R0 as DistributedReducer<I0, Source, O0>>::ReduceAFactory, <R1 as DistributedReducer<I1, Source, O1>>::ReduceAFactory, <R2 as DistributedReducer<I2, Source, O2>>::ReduceAFactory, <R3 as DistributedReducer<I3, Source, O3>>::ReduceAFactory>`

`type ReduceA = ReduceA4<<R0 as DistributedReducer<I0, Source, O0>>::ReduceA, <R1 as DistributedReducer<I1, Source, O1>>::ReduceA, <R2 as DistributedReducer<I2, Source, O2>>::ReduceA, <R3 as DistributedReducer<I3, Source, O3>>::ReduceA>`

`type ReduceB = ReduceB4<<R0 as DistributedReducer<I0, Source, O0>>::ReduceB, <R1 as DistributedReducer<I1, Source, O1>>::ReduceB, <R2 as DistributedReducer<I2, Source, O2>>::ReduceB, <R3 as DistributedReducer<I3, Source, O3>>::ReduceB>`

`fn reducers( self ) -> ((I0, I1, I2, I3), <(R0, R1, R2, R3) as DistributedReducer<(I0, I1, I2, I3), Source, (O0, O1, O2, O3)>>::ReduceAFactory, <(R0, R1, R2, R3) as DistributedReducer<(I0, I1, I2, I3), Source, (O0, O1, O2, O3)>>::ReduceB)`[src]

`impl<Source> DistributedReducer<(), Source, ()> for ()`[src]

`type ReduceAFactory = ReduceA0Factory`

`type ReduceA = ReduceA0`

`type ReduceB = ReduceB0`

`fn reducers( self ) -> ((), <() as DistributedReducer<(), Source, ()>>::ReduceAFactory, <() as DistributedReducer<(), Source, ()>>::ReduceB)`[src]

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

`type ReduceAFactory = SumReducerFactory<<I as DistributedIteratorMulti<Source>>::Item, B>`

`type ReduceA = SumReducer<<I as DistributedIteratorMulti<Source>>::Item, B>`

`type ReduceB = SumReducer<B, B>`

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

`impl<I, Source> DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>> for Max<I> where I: DistributedIteratorMulti<Source>, <I as DistributedIteratorMulti<Source>>::Item: Ord, <I as DistributedIteratorMulti<Source>>::Item: ProcessSend,` [src]

`type ReduceAFactory = CombineReducerFactory<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, Max>`

`type ReduceA = CombineReducer<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, Max>`

`type ReduceB = CombineReducer<Option<<I as DistributedIteratorMulti<Source>>::Item>, <I as DistributedIteratorMulti<Source>>::Item, Max>`

`fn reducers( self ) -> (I, <Max<I> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceAFactory, <Max<I> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceB)`[src]

`impl<I, Source> DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>> for Min<I> where I: DistributedIteratorMulti<Source>, <I as DistributedIteratorMulti<Source>>::Item: Ord, <I as DistributedIteratorMulti<Source>>::Item: ProcessSend,` [src]

`type ReduceAFactory = CombineReducerFactory<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, Min>`

`type ReduceA = CombineReducer<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, Min>`

`type ReduceB = CombineReducer<Option<<I as DistributedIteratorMulti<Source>>::Item>, <I as DistributedIteratorMulti<Source>>::Item, Min>`

`fn reducers( self ) -> (I, <Min<I> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceAFactory, <Min<I> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceB)`[src]

`impl<I, Source> DistributedReducer<I, Source, usize> for Count<I> where I: DistributedIteratorMulti<Source>, <I as DistributedIteratorMulti<Source>>::Item: 'static,` [src]

`type ReduceAFactory = CountReducerFactory<<I as DistributedIteratorMulti<Source>>::Item>`

`type ReduceA = CountReducer<<I as DistributedIteratorMulti<Source>>::Item>`

`type ReduceB = SumReducer<usize, usize>`

`fn reducers( self ) -> (I, <Count<I> as DistributedReducer<I, Source, usize>>::ReduceAFactory, <Count<I> as DistributedReducer<I, Source, usize>>::ReduceB)`[src]

`impl<I, Source> DistributedReducer<I, Source, SampleUnstable<<I as DistributedIteratorMulti<Source>>::Item>> for SampleUnstable<I> where I: DistributedIteratorMulti<Source>, <I as DistributedIteratorMulti<Source>>::Item: ProcessSend,` [src]

`type ReduceAFactory = SampleUnstableReducerFactory<<I as DistributedIteratorMulti<Source>>::Item>`

`type ReduceA = SampleUnstableReducer<<I as DistributedIteratorMulti<Source>>::Item>`

`type ReduceB = SumReducer<SampleUnstable<<I as DistributedIteratorMulti<Source>>::Item>, SampleUnstable<<I as DistributedIteratorMulti<Source>>::Item>>`

`fn reducers( self ) -> (I, <SampleUnstable<I> as DistributedReducer<I, Source, SampleUnstable<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceAFactory, <SampleUnstable<I> as DistributedReducer<I, Source, SampleUnstable<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceB)`[src]

`type ReduceAFactory = MostFrequentReducerFactory<<I as DistributedIteratorMulti<Source>>::Item>`

`type ReduceA = MostFrequentReducer<<I as DistributedIteratorMulti<Source>>::Item>`

`type ReduceB = NonzeroReducer<SumReducer<Top<<I as DistributedIteratorMulti<Source>>::Item, usize>, Zeroable<Top<<I as DistributedIteratorMulti<Source>>::Item, usize>>>>`

`fn reducers( self ) -> (I, <MostFrequent<I> as DistributedReducer<I, Source, Top<<I as DistributedIteratorMulti<Source>>::Item, usize>>>::ReduceAFactory, <MostFrequent<I> as DistributedReducer<I, Source, Top<<I as DistributedIteratorMulti<Source>>::Item, usize>>>::ReduceB)`[src]

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

`type ReduceAFactory = MostDistinctReducerFactory<A, B>`

`type ReduceA = MostDistinctReducer<A, B>`

`type ReduceB = NonzeroReducer<SumReducer<Top<A, HyperLogLogMagnitude<B>>, Zeroable<Top<A, HyperLogLogMagnitude<B>>>>>`

`fn reducers( self ) -> (I, <MostDistinct<I> as DistributedReducer<I, Source, Top<A, HyperLogLogMagnitude<B>>>>::ReduceAFactory, <MostDistinct<I> as DistributedReducer<I, Source, Top<A, HyperLogLogMagnitude<B>>>>::ReduceB)`[src]

`type ReduceAFactory = CombineReducerFactory<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, CombineFn<F>>`

`type ReduceA = CombineReducer<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, CombineFn<F>>`

`type ReduceB = CombineReducer<Option<<I as DistributedIteratorMulti<Source>>::Item>, <I as DistributedIteratorMulti<Source>>::Item, CombineFn<F>>`

`fn reducers( self ) -> (I, <Combine<I, F> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceAFactory, <Combine<I, F> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceB)`[src]

`type ReduceAFactory = CombineReducerFactory<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, MaxBy<F>>`

`type ReduceA = CombineReducer<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, MaxBy<F>>`

`type ReduceB = CombineReducer<Option<<I as DistributedIteratorMulti<Source>>::Item>, <I as DistributedIteratorMulti<Source>>::Item, MaxBy<F>>`

`fn reducers( self ) -> (I, <MaxBy<I, F> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceAFactory, <MaxBy<I, F> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceB)`[src]

`type ReduceAFactory = CombineReducerFactory<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, MinBy<F>>`

`type ReduceA = CombineReducer<<I as DistributedIteratorMulti<Source>>::Item, <I as DistributedIteratorMulti<Source>>::Item, MinBy<F>>`

`type ReduceB = CombineReducer<Option<<I as DistributedIteratorMulti<Source>>::Item>, <I as DistributedIteratorMulti<Source>>::Item, MinBy<F>>`

`fn reducers( self ) -> (I, <MinBy<I, F> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceAFactory, <MinBy<I, F> as DistributedReducer<I, Source, Option<<I as DistributedIteratorMulti<Source>>::Item>>>::ReduceB)`[src]

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

`type ReduceAFactory = AllReducerFactory<<I as DistributedIteratorMulti<Source>>::Item, F>`

`type ReduceA = AllReducer<<I as DistributedIteratorMulti<Source>>::Item, F>`

`type ReduceB = BoolAndReducer`