Trait amadeus_core::dist_iter::DistributedReducer

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

Associated Types

type ReduceAFactory: ReduceFactory<Reducer = Self::ReduceA>

type ReduceA: ReducerA<Item = <I as DistributedIteratorMulti<Source>>::Item> + ProcessSend

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

Loading content...

Required methods

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

Loading content...

Implementations on Foreign Types

impl<Source> DistributedReducer<(), Source, ()> for () where
    Source: , 

type ReduceAFactory = ReduceA0Factory

type ReduceA = ReduceA0

type ReduceB = ReduceB0

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

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

type ReduceAFactory = ReduceA1Factory<R0::ReduceAFactory>

type ReduceA = ReduceA1<R0::ReduceA>

type ReduceB = ReduceB1<R0::ReduceB>

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

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

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

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

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

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

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

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

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

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

fn reducers(self) -> ((I0, I1, I2), Self::ReduceAFactory, Self::ReduceB)

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

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

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

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

fn reducers(self) -> ((I0, I1, I2, I3), Self::ReduceAFactory, Self::ReduceB)

impl<I0: DistributedIteratorMulti<Source>, I1: DistributedIteratorMulti<Source>, I2: DistributedIteratorMulti<Source>, I3: DistributedIteratorMulti<Source>, I4: DistributedIteratorMulti<Source>, 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>, O0, O1, O2, O3, O4> DistributedReducer<(I0, I1, I2, I3, I4), Source, (O0, O1, O2, O3, O4)> for (R0, R1, R2, R3, R4) where
    Source: Copy, 

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

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

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

fn reducers(self) -> ((I0, I1, I2, I3, I4), Self::ReduceAFactory, Self::ReduceB)

impl<I0: DistributedIteratorMulti<Source>, I1: DistributedIteratorMulti<Source>, I2: DistributedIteratorMulti<Source>, I3: DistributedIteratorMulti<Source>, I4: DistributedIteratorMulti<Source>, I5: DistributedIteratorMulti<Source>, 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>, 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
    Source: Copy, 

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

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

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

fn reducers(
    self
) -> ((I0, I1, I2, I3, I4, I5), Self::ReduceAFactory, Self::ReduceB)

impl<I0: DistributedIteratorMulti<Source>, I1: DistributedIteratorMulti<Source>, I2: DistributedIteratorMulti<Source>, I3: DistributedIteratorMulti<Source>, I4: DistributedIteratorMulti<Source>, I5: DistributedIteratorMulti<Source>, I6: DistributedIteratorMulti<Source>, 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>, 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
    Source: Copy, 

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

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

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

fn reducers(
    self
) -> ((I0, I1, I2, I3, I4, I5, I6), Self::ReduceAFactory, Self::ReduceB)

impl<I0: DistributedIteratorMulti<Source>, I1: DistributedIteratorMulti<Source>, I2: DistributedIteratorMulti<Source>, I3: DistributedIteratorMulti<Source>, I4: DistributedIteratorMulti<Source>, I5: DistributedIteratorMulti<Source>, I6: DistributedIteratorMulti<Source>, I7: DistributedIteratorMulti<Source>, 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>, 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
    Source: Copy, 

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

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

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

fn reducers(
    self
) -> ((I0, I1, I2, I3, I4, I5, I6, I7), Self::ReduceAFactory, Self::ReduceB)

Loading content...

Implementors

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

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

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

type ReduceB = SumReducer<B, B>

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

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

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

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

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

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

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

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

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

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

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

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

type ReduceAFactory = CountReducerFactory<I::Item>

type ReduceA = CountReducer<I::Item>

type ReduceB = SumReducer<usize, usize>

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

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

type ReduceAFactory = SampleUnstableReducerFactory<I::Item>

type ReduceA = SampleUnstableReducer<I::Item>

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

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

impl<I: DistributedIteratorMulti<Source>, Source> DistributedReducer<I, Source, Top<<I as DistributedIteratorMulti<Source>>::Item, usize>> for MostFrequent<I> where
    I::Item: Clone + Hash + Eq + ProcessSend, 

type ReduceAFactory = MostFrequentReducerFactory<I::Item>

type ReduceA = MostFrequentReducer<I::Item>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type ReduceB = BoolAndReducer

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

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

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

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

type ReduceB = BoolOrReducer

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

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

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

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

type ReduceB = PushReducer<()>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<I: DistributedIteratorMulti<Source>, Source, T: FromDistributedIterator<I::Item>> DistributedReducer<I, Source, T> for Collect<I, T>

type ReduceAFactory = T::ReduceAFactory

type ReduceA = T::ReduceA

type ReduceB = T::ReduceB

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

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

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, Self::ReduceAFactory, Self::ReduceB)

Loading content...