[−][src]Trait amadeus_core::dist_sink::DistributedSink
Associated Types
type ReduceAFactory: Factory<Item = Self::ReduceA> + Clone + ProcessSend
type ReduceBFactory: Factory<Item = Self::ReduceB>
type ReduceA: ReducerSend<Item = <I as DistributedPipe<Source>>::Item> + ProcessSend
type ReduceB: ReducerProcessSend<Item = <Self::ReduceA as Reducer>::Output> + ProcessSend
type ReduceC: Reducer<Item = <Self::ReduceB as Reducer>::Output, Output = B>
Required methods
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
Implementations on Foreign Types
impl<Source> DistributedSink<(), Source, ()> for () where
Source: ,
[src]
Source: ,
type ReduceAFactory = ReduceA0Factory
type ReduceBFactory = ReduceC0Factory
type ReduceA = ReduceA0
type ReduceB = ReduceC0
type ReduceC = ReduceC0
fn reducers(
self
) -> ((), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> ((), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I0: DistributedPipe<Source>, Source, R0: DistributedSink<I0, Source, O0>, O0> DistributedSink<(I0,), Source, (O0,)> for (R0,) where
Source: ,
[src]
Source: ,
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>
fn reducers(
self
) -> ((I0,), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> ((I0,), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I0: DistributedPipe<Source>, I1: DistributedPipe<Source>, Source, R0: DistributedSink<I0, Source, O0>, R1: DistributedSink<I1, Source, O1>, O0, O1> DistributedSink<(I0, I1), Source, (O0, O1)> for (R0, R1) where
Source: Copy,
[src]
Source: Copy,
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>
fn reducers(
self
) -> ((I0, I1), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> ((I0, I1), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I0: DistributedPipe<Source>, I1: DistributedPipe<Source>, I2: DistributedPipe<Source>, Source, R0: DistributedSink<I0, Source, O0>, R1: DistributedSink<I1, Source, O1>, R2: DistributedSink<I2, Source, O2>, O0, O1, O2> DistributedSink<(I0, I1, I2), Source, (O0, O1, O2)> for (R0, R1, R2) where
Source: Copy,
[src]
Source: Copy,
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>
fn reducers(
self
) -> ((I0, I1, I2), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> ((I0, I1, I2), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I0: DistributedPipe<Source>, I1: DistributedPipe<Source>, I2: DistributedPipe<Source>, I3: DistributedPipe<Source>, Source, R0: DistributedSink<I0, Source, O0>, R1: DistributedSink<I1, Source, O1>, R2: DistributedSink<I2, Source, O2>, R3: DistributedSink<I3, Source, O3>, O0, O1, O2, O3> DistributedSink<(I0, I1, I2, I3), Source, (O0, O1, O2, O3)> for (R0, R1, R2, R3) where
Source: Copy,
[src]
Source: Copy,
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>
fn reducers(
self
) -> ((I0, I1, I2, I3), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> ((I0, I1, I2, I3), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I0: DistributedPipe<Source>, I1: DistributedPipe<Source>, I2: DistributedPipe<Source>, I3: DistributedPipe<Source>, I4: DistributedPipe<Source>, Source, R0: DistributedSink<I0, Source, O0>, R1: DistributedSink<I1, Source, O1>, R2: DistributedSink<I2, Source, O2>, R3: DistributedSink<I3, Source, O3>, R4: DistributedSink<I4, Source, O4>, O0, O1, O2, O3, O4> DistributedSink<(I0, I1, I2, I3, I4), Source, (O0, O1, O2, O3, O4)> for (R0, R1, R2, R3, R4) where
Source: Copy,
[src]
Source: Copy,
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>
fn reducers(
self
) -> ((I0, I1, I2, I3, I4), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> ((I0, I1, I2, I3, I4), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I0: DistributedPipe<Source>, I1: DistributedPipe<Source>, I2: DistributedPipe<Source>, I3: DistributedPipe<Source>, I4: DistributedPipe<Source>, I5: DistributedPipe<Source>, Source, R0: DistributedSink<I0, Source, O0>, R1: DistributedSink<I1, Source, O1>, R2: DistributedSink<I2, Source, O2>, R3: DistributedSink<I3, Source, O3>, R4: DistributedSink<I4, Source, O4>, R5: DistributedSink<I5, Source, O5>, O0, O1, O2, O3, O4, O5> DistributedSink<(I0, I1, I2, I3, I4, I5), Source, (O0, O1, O2, O3, O4, O5)> for (R0, R1, R2, R3, R4, R5) where
Source: Copy,
[src]
Source: Copy,
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>
fn reducers(
self
) -> ((I0, I1, I2, I3, I4, I5), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> ((I0, I1, I2, I3, I4, I5), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I0: DistributedPipe<Source>, I1: DistributedPipe<Source>, I2: DistributedPipe<Source>, I3: DistributedPipe<Source>, I4: DistributedPipe<Source>, I5: DistributedPipe<Source>, I6: DistributedPipe<Source>, Source, R0: DistributedSink<I0, Source, O0>, R1: DistributedSink<I1, Source, O1>, R2: DistributedSink<I2, Source, O2>, R3: DistributedSink<I3, Source, O3>, R4: DistributedSink<I4, Source, O4>, R5: DistributedSink<I5, Source, O5>, R6: DistributedSink<I6, Source, O6>, O0, O1, O2, O3, O4, O5, O6> DistributedSink<(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,
[src]
Source: Copy,
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>
fn reducers(
self
) -> ((I0, I1, I2, I3, I4, I5, I6), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> ((I0, I1, I2, I3, I4, I5, I6), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I0: DistributedPipe<Source>, I1: DistributedPipe<Source>, I2: DistributedPipe<Source>, I3: DistributedPipe<Source>, I4: DistributedPipe<Source>, I5: DistributedPipe<Source>, I6: DistributedPipe<Source>, I7: DistributedPipe<Source>, Source, R0: DistributedSink<I0, Source, O0>, R1: DistributedSink<I1, Source, O1>, R2: DistributedSink<I2, Source, O2>, R3: DistributedSink<I3, Source, O3>, R4: DistributedSink<I4, Source, O4>, R5: DistributedSink<I5, Source, O5>, R6: DistributedSink<I6, Source, O6>, R7: DistributedSink<I7, Source, O7>, O0, O1, O2, O3, O4, O5, O6, O7> DistributedSink<(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,
[src]
Source: Copy,
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>
fn reducers(
self
) -> ((I0, I1, I2, I3, I4, I5, I6, I7), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> ((I0, I1, I2, I3, I4, I5, I6, I7), Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
Implementors
impl<I: DistributedPipe<Source>, B, Source> DistributedSink<I, Source, B> for Sum<I, B> where
B: Sum<I::Item> + Sum<B> + ProcessSend,
I::Item: 'static,
[src]
B: Sum<I::Item> + Sum<B> + ProcessSend,
I::Item: 'static,
type ReduceAFactory = SumReduceFactory<I::Item, B>
type ReduceBFactory = SumReduceFactory<B, B>
type ReduceA = SumReducer<I::Item, B>
type ReduceB = SumReducer<B, B>
type ReduceC = SumReducer<B, B>
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I: DistributedPipe<Source>, Source> DistributedSink<I, Source, Option<<I as DistributedPipe<Source>>::Item>> for Max<I> where
I::Item: Ord + ProcessSend,
[src]
I::Item: Ord + ProcessSend,
type ReduceAFactory = CombineReduceFactory<I::Item, I::Item, Max>
type ReduceBFactory = CombineReduceFactory<Option<I::Item>, I::Item, Max>
type ReduceA = CombineReducer<I::Item, I::Item, Max>
type ReduceB = CombineReducer<Option<I::Item>, I::Item, Max>
type ReduceC = CombineReducer<Option<I::Item>, I::Item, Max>
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I: DistributedPipe<Source>, Source> DistributedSink<I, Source, Option<<I as DistributedPipe<Source>>::Item>> for Min<I> where
I::Item: Ord + ProcessSend,
[src]
I::Item: Ord + ProcessSend,
type ReduceAFactory = CombineReduceFactory<I::Item, I::Item, Min>
type ReduceBFactory = CombineReduceFactory<Option<I::Item>, I::Item, Min>
type ReduceA = CombineReducer<I::Item, I::Item, Min>
type ReduceB = CombineReducer<Option<I::Item>, I::Item, Min>
type ReduceC = CombineReducer<Option<I::Item>, I::Item, Min>
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I: DistributedPipe<Source>, Source> DistributedSink<I, Source, usize> for Count<I> where
I::Item: 'static,
[src]
I::Item: 'static,
type ReduceAFactory = CountReduceFactory<I::Item>
type ReduceBFactory = SumReduceFactory<usize, usize>
type ReduceA = CountReducer<I::Item>
type ReduceB = SumReducer<usize, usize>
type ReduceC = SumReducer<usize, usize>
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I: DistributedPipe<Source>, Source> DistributedSink<I, Source, SampleUnstable<<I as DistributedPipe<Source>>::Item>> for SampleUnstable<I> where
I::Item: ProcessSend,
[src]
I::Item: ProcessSend,
type ReduceAFactory = SampleUnstableReduceFactory<I::Item>
type ReduceBFactory = SumReduceFactory<SASampleUnstable<I::Item>, SASampleUnstable<I::Item>>
type ReduceA = SampleUnstableReducer<I::Item>
type ReduceB = SumReducer<SASampleUnstable<I::Item>, SASampleUnstable<I::Item>>
type ReduceC = SumReducer<SASampleUnstable<I::Item>, SASampleUnstable<I::Item>>
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I: DistributedPipe<Source>, Source> DistributedSink<I, Source, Top<<I as DistributedPipe<Source>>::Item, usize>> for MostFrequent<I> where
I::Item: Clone + Hash + Eq + ProcessSend,
[src]
I::Item: Clone + Hash + Eq + ProcessSend,
type ReduceAFactory = MostFrequentReduceFactory<I::Item>
type ReduceBFactory = NonzeroReduceFactory<SumReduceFactory<Top<I::Item, usize>, Zeroable<Top<I::Item, usize>>>>
type ReduceA = MostFrequentReducer<I::Item>
type ReduceB = NonzeroReducer<SumReducer<Top<I::Item, usize>, Zeroable<Top<I::Item, usize>>>>
type ReduceC = NonzeroReducer<SumReducer<Top<I::Item, usize>, Zeroable<Top<I::Item, usize>>>>
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I: DistributedPipe<Source>, Source, F> DistributedSink<I, Source, Option<<I as DistributedPipe<Source>>::Item>> for Combine<I, F> where
F: FnMut(I::Item, I::Item) -> I::Item + Clone + ProcessSend,
I::Item: ProcessSend,
[src]
F: FnMut(I::Item, I::Item) -> I::Item + Clone + ProcessSend,
I::Item: ProcessSend,
type ReduceAFactory = CombineReduceFactory<I::Item, I::Item, CombineFn<F>>
type ReduceBFactory = CombineReduceFactory<Option<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>>
type ReduceC = CombineReducer<Option<I::Item>, I::Item, CombineFn<F>>
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I: DistributedPipe<Source>, Source, F> DistributedSink<I, Source, Option<<I as DistributedPipe<Source>>::Item>> for MaxBy<I, F> where
F: FnMut(&I::Item, &I::Item) -> Ordering + Clone + ProcessSend,
I::Item: ProcessSend,
[src]
F: FnMut(&I::Item, &I::Item) -> Ordering + Clone + ProcessSend,
I::Item: ProcessSend,
type ReduceAFactory = CombineReduceFactory<I::Item, I::Item, MaxBy<F>>
type ReduceBFactory = CombineReduceFactory<Option<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>>
type ReduceC = CombineReducer<Option<I::Item>, I::Item, MaxBy<F>>
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I: DistributedPipe<Source>, Source, F> DistributedSink<I, Source, Option<<I as DistributedPipe<Source>>::Item>> for MinBy<I, F> where
F: FnMut(&I::Item, &I::Item) -> Ordering + Clone + ProcessSend,
I::Item: ProcessSend,
[src]
F: FnMut(&I::Item, &I::Item) -> Ordering + Clone + ProcessSend,
I::Item: ProcessSend,
type ReduceAFactory = CombineReduceFactory<I::Item, I::Item, MinBy<F>>
type ReduceBFactory = CombineReduceFactory<Option<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>>
type ReduceC = CombineReducer<Option<I::Item>, I::Item, MinBy<F>>
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I: DistributedPipe<Source>, Source, F> DistributedSink<I, Source, bool> for All<I, F> where
F: FnMut(I::Item) -> bool + Clone + ProcessSend,
I::Item: 'static,
[src]
F: FnMut(I::Item) -> bool + Clone + ProcessSend,
I::Item: 'static,
type ReduceAFactory = AllReduceFactory<I::Item, F>
type ReduceBFactory = BoolAndReduceFactory
type ReduceA = AllReducer<I::Item, F>
type ReduceB = BoolAndReducer
type ReduceC = BoolAndReducer
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I: DistributedPipe<Source>, Source, F> DistributedSink<I, Source, bool> for Any<I, F> where
F: FnMut(I::Item) -> bool + Clone + ProcessSend,
I::Item: 'static,
[src]
F: FnMut(I::Item) -> bool + Clone + ProcessSend,
I::Item: 'static,
type ReduceAFactory = AnyReduceFactory<I::Item, F>
type ReduceBFactory = BoolOrReduceFactory
type ReduceA = AnyReducer<I::Item, F>
type ReduceB = BoolOrReducer
type ReduceC = BoolOrReducer
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I: DistributedPipe<Source>, Source, F> DistributedSink<I, Source, ()> for ForEach<I, F> where
F: FnMut(I::Item) + Clone + ProcessSend,
I::Item: 'static,
[src]
F: FnMut(I::Item) + Clone + ProcessSend,
I::Item: 'static,
type ReduceAFactory = ForEachReduceFactory<I::Item, F>
type ReduceBFactory = DefaultReduceFactory<Self::ReduceB>
type ReduceA = ForEachReducer<I::Item, F>
type ReduceB = PushReducer<()>
type ReduceC = PushReducer<()>
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I: DistributedPipe<Source>, Source, F, B> DistributedSink<I, Source, Option<<I as DistributedPipe<Source>>::Item>> for MaxByKey<I, F> where
F: FnMut(&I::Item) -> B + Clone + ProcessSend,
I::Item: ProcessSend,
B: Ord + 'static,
[src]
F: FnMut(&I::Item) -> B + Clone + ProcessSend,
I::Item: ProcessSend,
B: Ord + 'static,
type ReduceAFactory = CombineReduceFactory<I::Item, I::Item, MaxByKey<F, B>>
type ReduceBFactory = CombineReduceFactory<Option<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>>
type ReduceC = CombineReducer<Option<I::Item>, I::Item, MaxByKey<F, B>>
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I: DistributedPipe<Source>, Source, F, B> DistributedSink<I, Source, Option<<I as DistributedPipe<Source>>::Item>> for MinByKey<I, F> where
F: FnMut(&I::Item) -> B + Clone + ProcessSend,
I::Item: ProcessSend,
B: Ord + 'static,
[src]
F: FnMut(&I::Item) -> B + Clone + ProcessSend,
I::Item: ProcessSend,
B: Ord + 'static,
type ReduceAFactory = CombineReduceFactory<I::Item, I::Item, MinByKey<F, B>>
type ReduceBFactory = CombineReduceFactory<Option<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>>
type ReduceC = CombineReducer<Option<I::Item>, I::Item, MinByKey<F, B>>
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I: DistributedPipe<Source>, Source, ID, F, B> DistributedSink<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,
[src]
ID: FnMut() -> B + Clone + ProcessSend,
F: FnMut(B, Either<I::Item, B>) -> B + Clone + ProcessSend,
B: ProcessSend,
I::Item: 'static,
type ReduceAFactory = FoldReducerAFactory<I::Item, ID, F, B>
type ReduceBFactory = FoldReducerBFactory<I::Item, ID, F, B>
type ReduceA = FoldReducerA<I::Item, ID, F, B>
type ReduceB = FoldReducerB<I::Item, ID, F, B>
type ReduceC = FoldReducerB<I::Item, ID, F, B>
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I: DistributedPipe<Source>, Source, T: FromDistributedStream<I::Item>> DistributedSink<I, Source, T> for Collect<I, T>
[src]
type ReduceAFactory = T::ReduceAFactory
type ReduceBFactory = T::ReduceBFactory
type ReduceA = T::ReduceA
type ReduceB = T::ReduceB
type ReduceC = T::ReduceC
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
impl<I: DistributedPipe<Source, Item = (A, B)>, Source, A, B> DistributedSink<I, Source, Top<A, HyperLogLogMagnitude<B>>> for MostDistinct<I> where
A: Clone + Hash + Eq + ProcessSend,
B: Hash + 'static,
[src]
A: Clone + Hash + Eq + ProcessSend,
B: Hash + 'static,
type ReduceAFactory = MostDistinctReduceFactory<A, B>
type ReduceBFactory = NonzeroReduceFactory<SumReduceFactory<Top<A, HyperLogLogMagnitude<B>>, Zeroable<Top<A, HyperLogLogMagnitude<B>>>>>
type ReduceA = MostDistinctReducer<A, B>
type ReduceB = NonzeroReducer<SumReducer<Top<A, HyperLogLogMagnitude<B>>, Zeroable<Top<A, HyperLogLogMagnitude<B>>>>>
type ReduceC = NonzeroReducer<SumReducer<Top<A, HyperLogLogMagnitude<B>>, Zeroable<Top<A, HyperLogLogMagnitude<B>>>>>
fn reducers(
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)
[src]
self
) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC)