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

#[must_use]pub trait ParallelSink<Item> {
    type Done;
    type Pipe: ParallelPipe<Item>;
    type ReduceA: ReducerSend<<Self::Pipe as ParallelPipe<Item>>::Output> + Clone + Send;
    type ReduceC: Reducer<<Self::ReduceA as ReducerSend<<Self::Pipe as ParallelPipe<Item>>::Output>>::Done, Done = Self::Done>;
    fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceC);
}

Associated Types

type Done

type Pipe: ParallelPipe<Item>

type ReduceA: ReducerSend<<Self::Pipe as ParallelPipe<Item>>::Output> + Clone + Send

type ReduceC: Reducer<<Self::ReduceA as ReducerSend<<Self::Pipe as ParallelPipe<Item>>::Output>>::Done, Done = Self::Done>

Loading content...

Required methods

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

Loading content...

Implementations on Foreign Types

impl<Item> ParallelSink<Item> for () where
    Item: , [src]

type Done = ()

type Pipe = ()

type ReduceA = ReduceA0

type ReduceC = ReduceC0

impl<Item, R0: ParallelSink<Item, Done = O0>, O0> ParallelSink<Item> for (R0,) where
    Item: , [src]

type Done = (O0,)

type Pipe = (R0::Pipe,)

type ReduceA = ReduceA1<R0::ReduceA>

type ReduceC = ReduceC1<R0::ReduceC>

impl<Item, R0: ParallelSink<Item, Done = O0>, R1: ParallelSink<Item, Done = O1>, O0, O1> ParallelSink<Item> for (R0, R1) where
    Item: Copy, [src]

type Done = (O0, O1)

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

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

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

impl<Item, R0: ParallelSink<Item, Done = O0>, R1: ParallelSink<Item, Done = O1>, R2: ParallelSink<Item, Done = O2>, O0, O1, O2> ParallelSink<Item> for (R0, R1, R2) where
    Item: Copy, [src]

type Done = (O0, O1, O2)

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

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

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

impl<Item, R0: ParallelSink<Item, Done = O0>, R1: ParallelSink<Item, Done = O1>, R2: ParallelSink<Item, Done = O2>, R3: ParallelSink<Item, Done = O3>, O0, O1, O2, O3> ParallelSink<Item> for (R0, R1, R2, R3) where
    Item: Copy, [src]

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

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

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

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

impl<Item, R0: ParallelSink<Item, Done = O0>, R1: ParallelSink<Item, Done = O1>, R2: ParallelSink<Item, Done = O2>, R3: ParallelSink<Item, Done = O3>, R4: ParallelSink<Item, Done = O4>, O0, O1, O2, O3, O4> ParallelSink<Item> for (R0, R1, R2, R3, R4) where
    Item: Copy, [src]

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

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

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

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

impl<Item, R0: ParallelSink<Item, Done = O0>, R1: ParallelSink<Item, Done = O1>, R2: ParallelSink<Item, Done = O2>, R3: ParallelSink<Item, Done = O3>, R4: ParallelSink<Item, Done = O4>, R5: ParallelSink<Item, Done = O5>, O0, O1, O2, O3, O4, O5> ParallelSink<Item> for (R0, R1, R2, R3, R4, R5) where
    Item: Copy, [src]

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

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

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

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

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

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

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

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

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

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

type Done = (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 ReduceA = ReduceA8<R0::ReduceA, R1::ReduceA, R2::ReduceA, R3::ReduceA, R4::ReduceA, R5::ReduceA, R6::ReduceA, R7::ReduceA>

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

Loading content...

Implementors

impl<A, B, C, Item, RefAItem> ParallelSink<Item> for Fork<A, B, C, RefAItem> where
    A: ParallelPipe<Item>,
    B: ParallelSink<A::Output>,
    C: ParallelSink<RefAItem>,
    RefAItem: 'static, [src]

type Done = (B::Done, C::Done)

type Pipe = Fork<A, B::Pipe, C::Pipe, RefAItem>

type ReduceA = ReduceA2<B::ReduceA, C::ReduceA>

type ReduceC = ReduceC2<B::ReduceC, C::ReduceC>

impl<A: ParallelPipe<Item>, B: ParallelSink<A::Output>, Item> ParallelSink<Item> for Pipe<A, B>[src]

type Done = B::Done

type Pipe = Pipe<A, B::Pipe>

type ReduceA = B::ReduceA

type ReduceC = B::ReduceC

impl<A: ParallelPipe<Item, Output = (T, U)>, B: ParallelSink<U>, Item, T, U> ParallelSink<Item> for GroupBy<A, B> where
    T: Eq + Hash + Send + 'static,
    <B::Pipe as ParallelPipe<U>>::Task: Clone + Send + 'static,
    B::ReduceA: Clone + Send + 'static,
    B::ReduceC: Clone,
    B::Done: Send + 'static, [src]

type Done = IndexMap<T, B::Done>

type Pipe = A

type ReduceA = GroupByReducerA<<B::Pipe as ParallelPipe<U>>::Task, B::ReduceA, T, U>

type ReduceC = GroupByReducerB<B::ReduceC, T, <B::ReduceA as ReducerSend<<B::Pipe as ParallelPipe<U>>::Output>>::Done>

impl<P: ParallelPipe<Item>, F, Item> ParallelSink<Item> for Sort<P, F> where
    F: Fn(&P::Output, &P::Output) -> Ordering + Clone + Send + 'static,
    P::Output: Clone + Send + 'static, [src]

type Done = <Self::ReduceC as Reducer<<Self::ReduceA as Reducer<P::Output>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<P::Output, SortFolder<F>, Inter>

type ReduceC = FolderSyncReducer<<Self::ReduceA as Reducer<P::Output>>::Done, SumZeroFolder<SASort<P::Output, F>>, Final>

impl<P: ParallelPipe<Item>, Item> ParallelSink<Item> for Count<P>[src]

type Done = <Self::ReduceC as Reducer<<Self::ReduceA as Reducer<P::Output>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<P::Output, CountFolder, Inter>

type ReduceC = FolderSyncReducer<<Self::ReduceA as Reducer<P::Output>>::Done, SumFolder<usize>, Final>

impl<P: ParallelPipe<Item>, Item> ParallelSink<Item> for Histogram<P> where
    P::Output: Hash + Ord + Send + 'static, [src]

type Done = <Self::ReduceC as Reducer<<Self::ReduceA as Reducer<P::Output>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<P::Output, HistogramFolder<P::Output, StepA>, Inter>

type ReduceC = FolderSyncReducer<<Self::ReduceA as Reducer<P::Output>>::Done, HistogramFolder<P::Output, StepB>, Final>

impl<P: ParallelPipe<Item>, Item> ParallelSink<Item> for Max<P> where
    P::Output: Ord + Send + 'static, [src]

type Done = <Self::ReduceC as Reducer<<Self::ReduceA as Reducer<P::Output>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<P::Output, Max<P::Output>, Inter>

type ReduceC = FolderSyncReducer<<Self::ReduceA as Reducer<P::Output>>::Done, Max<P::Output>, Final>

impl<P: ParallelPipe<Item>, Item> ParallelSink<Item> for Min<P> where
    P::Output: Ord + Send + 'static, [src]

type Done = <Self::ReduceC as Reducer<<Self::ReduceA as Reducer<P::Output>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<P::Output, Min<P::Output>, Inter>

type ReduceC = FolderSyncReducer<<Self::ReduceA as Reducer<P::Output>>::Done, Min<P::Output>, Final>

impl<P: ParallelPipe<Item>, Item> ParallelSink<Item> for MostFrequent<P> where
    P::Output: Clone + Hash + Eq + Send + 'static, [src]

type Done = <Self::ReduceC as Reducer<<Self::ReduceA as Reducer<P::Output>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<P::Output, MostFrequentFolder, Inter>

type ReduceC = FolderSyncReducer<<Self::ReduceA as Reducer<P::Output>>::Done, SumZeroFolder<Top<P::Output, usize>>, Final>

impl<P: ParallelPipe<Item>, Item> ParallelSink<Item> for SampleUnstable<P> where
    P::Output: Send + 'static, [src]

type Done = <Self::ReduceC as Reducer<<Self::ReduceA as Reducer<P::Output>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<P::Output, SampleUnstableFolder, Inter>

type ReduceC = FolderSyncReducer<<Self::ReduceA as Reducer<P::Output>>::Done, SumFolder<SASampleUnstable<P::Output>>, Final>

impl<P: ParallelPipe<Item>, Item, B> ParallelSink<Item> for Sum<P, B> where
    B: Sum<P::Output> + Sum<B> + Send + 'static, [src]

type Done = <Self::ReduceC as Reducer<<Self::ReduceA as Reducer<P::Output>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<P::Output, SumFolder<B>, Inter>

type ReduceC = FolderSyncReducer<<Self::ReduceA as Reducer<P::Output>>::Done, SumFolder<B>, Final>

impl<P: ParallelPipe<Item>, Item, F> ParallelSink<Item> for All<P, F> where
    F: FnMut<(P::Output,), Output = bool> + Clone + Send + 'static, [src]

type Done = bool

type Pipe = P

type ReduceA = AllReducer<P::Output, F>

type ReduceC = BoolAndReducer

impl<P: ParallelPipe<Item>, Item, F> ParallelSink<Item> for Any<P, F> where
    F: FnMut<(P::Output,), Output = bool> + Clone + Send + 'static, [src]

type Done = bool

type Pipe = P

type ReduceA = AnyReducer<P::Output, F>

type ReduceC = BoolOrReducer

impl<P: ParallelPipe<Item>, Item, F> ParallelSink<Item> for Combine<P, F> where
    F: FnMut<(P::Output, P::Output), Output = P::Output> + Clone + Send + 'static,
    P::Output: Send + 'static, [src]

type Done = <Self::ReduceC as Reducer<<Self::ReduceA as Reducer<P::Output>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<P::Output, ReduceFn<F, P::Output>, Inter>

type ReduceC = FolderSyncReducer<<Self::ReduceA as Reducer<P::Output>>::Done, ReduceFn<F, P::Output>, Final>

impl<P: ParallelPipe<Item>, Item, F> ParallelSink<Item> for ForEach<P, F> where
    F: FnMut<(P::Output,), Output = ()> + Clone + Send + 'static, [src]

type Done = ()

type Pipe = P

type ReduceA = ForEachReducer<P::Output, F>

type ReduceC = PushReducer<()>

impl<P: ParallelPipe<Item>, Item, F> ParallelSink<Item> for MaxBy<P, F> where
    F: for<'a, 'b> FnMut<(&'a P::Output, &'b P::Output), Output = Ordering> + Clone + Send + 'static,
    P::Output: Send + 'static, [src]

type Done = <Self::ReduceC as Reducer<<Self::ReduceA as Reducer<P::Output>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<P::Output, MaxBy<P::Output, F>, Inter>

type ReduceC = FolderSyncReducer<<Self::ReduceA as Reducer<P::Output>>::Done, MaxBy<P::Output, F>, Final>

impl<P: ParallelPipe<Item>, Item, F> ParallelSink<Item> for MinBy<P, F> where
    F: for<'a, 'b> FnMut<(&'a P::Output, &'b P::Output), Output = Ordering> + Clone + Send + 'static,
    P::Output: Send + 'static, [src]

type Done = <Self::ReduceC as Reducer<<Self::ReduceA as Reducer<P::Output>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<P::Output, MinBy<P::Output, F>, Inter>

type ReduceC = FolderSyncReducer<<Self::ReduceA as Reducer<P::Output>>::Done, MinBy<P::Output, F>, Final>

impl<P: ParallelPipe<Item>, Item, F, B> ParallelSink<Item> for MaxByKey<P, F> where
    F: for<'a> FnMut<(&'a P::Output,), Output = B> + Clone + Send + 'static,
    B: Ord + 'static,
    P::Output: Send + 'static, [src]

type Done = <Self::ReduceC as Reducer<<Self::ReduceA as Reducer<P::Output>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<P::Output, MaxByKey<P::Output, F, B>, Inter>

type ReduceC = FolderSyncReducer<<Self::ReduceA as Reducer<P::Output>>::Done, MaxByKey<P::Output, F, B>, Final>

impl<P: ParallelPipe<Item>, Item, F, B> ParallelSink<Item> for MinByKey<P, F> where
    F: for<'a> FnMut<(&'a P::Output,), Output = B> + Clone + Send + 'static,
    B: Ord + 'static,
    P::Output: Send + 'static, [src]

type Done = <Self::ReduceC as Reducer<<Self::ReduceA as Reducer<P::Output>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<P::Output, MinByKey<P::Output, F, B>, Inter>

type ReduceC = FolderSyncReducer<<Self::ReduceA as Reducer<P::Output>>::Done, MinByKey<P::Output, F, B>, Final>

impl<P: ParallelPipe<Item>, Item, ID, F, B> ParallelSink<Item> for Fold<P, ID, F, B> where
    ID: FnMut<(), Output = B> + Clone + Send + 'static,
    F: FnMut<(B, Either<P::Output, B>), Output = B> + Clone + Send + 'static,
    B: Send + 'static, [src]

type Done = <Self::ReduceC as Reducer<<Self::ReduceA as Reducer<P::Output>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<P::Output, FoldFolder<P::Output, ID, F, B, StepA>, Inter>

type ReduceC = FolderSyncReducer<<Self::ReduceA as Reducer<P::Output>>::Done, FoldFolder<P::Output, ID, F, B, StepB>, Final>

impl<P: ParallelPipe<Item>, Item, T: FromParallelStream<P::Output>> ParallelSink<Item> for Collect<P, T>[src]

type Done = T

type Pipe = P

type ReduceA = T::ReduceA

type ReduceC = T::ReduceC

impl<P: ParallelPipe<Item, Output = f64>, Item> ParallelSink<Item> for Mean<P>[src]

type Done = <Self::ReduceC as Reducer<<Self::ReduceA as Reducer<P::Output>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<P::Output, MeanFolder<StepA>, Inter>

type ReduceC = FolderSyncReducer<<Self::ReduceA as Reducer<P::Output>>::Done, MeanFolder<StepB>, Final>

impl<P: ParallelPipe<Item, Output = f64>, Item> ParallelSink<Item> for StdDev<P>[src]

type Done = <Self::ReduceC as Reducer<<Self::ReduceA as Reducer<P::Output>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<P::Output, SDFolder<StepA>, Inter>

type ReduceC = FolderSyncReducer<<Self::ReduceA as Reducer<P::Output>>::Done, SDFolder<StepB>, Final>

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

type Done = <Self::ReduceC as Reducer<<Self::ReduceA as Reducer<P::Output>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<P::Output, MostDistinctFolder, Inter>

type ReduceC = FolderSyncReducer<<Self::ReduceA as Reducer<P::Output>>::Done, SumZeroFolder<Top<A, HyperLogLogMagnitude<B>>>, Final>

Loading content...