Trait amadeus::par_sink::ParallelSink

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

Associated Types

type Output

type Pipe: ParallelPipe<Source>

type ReduceAFactory: Factory

type ReduceA: ReducerSend + Send

type ReduceC: Reducer

Loading content...

Required methods

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

Loading content...

Implementations on Foreign Types

impl<Source, R0, R1, R2, R3, R4, R5, O0, O1, O2, O3, O4, O5> ParallelSink<Source> for (R0, R1, R2, R3, R4, R5) where
    R0: ParallelSink<Source, Output = O0>,
    R1: ParallelSink<Source, Output = O1>,
    R2: ParallelSink<Source, Output = O2>,
    R3: ParallelSink<Source, Output = O3>,
    R4: ParallelSink<Source, Output = O4>,
    R5: ParallelSink<Source, Output = O5>,
    Source: Copy, 

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

type Pipe = (<R0 as ParallelSink<Source>>::Pipe, <R1 as ParallelSink<Source>>::Pipe, <R2 as ParallelSink<Source>>::Pipe, <R3 as ParallelSink<Source>>::Pipe, <R4 as ParallelSink<Source>>::Pipe, <R5 as ParallelSink<Source>>::Pipe)

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

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

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

fn reducers(
    self
) -> (<(R0, R1, R2, R3, R4, R5) as ParallelSink<Source>>::Pipe, <(R0, R1, R2, R3, R4, R5) as ParallelSink<Source>>::ReduceAFactory, <(R0, R1, R2, R3, R4, R5) as ParallelSink<Source>>::ReduceC)

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

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

type Pipe = (<R0 as ParallelSink<Source>>::Pipe, <R1 as ParallelSink<Source>>::Pipe, <R2 as ParallelSink<Source>>::Pipe, <R3 as ParallelSink<Source>>::Pipe)

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

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

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

fn reducers(
    self
) -> (<(R0, R1, R2, R3) as ParallelSink<Source>>::Pipe, <(R0, R1, R2, R3) as ParallelSink<Source>>::ReduceAFactory, <(R0, R1, R2, R3) as ParallelSink<Source>>::ReduceC)

impl<Source, R0, R1, R2, O0, O1, O2> ParallelSink<Source> for (R0, R1, R2) where
    R0: ParallelSink<Source, Output = O0>,
    R1: ParallelSink<Source, Output = O1>,
    R2: ParallelSink<Source, Output = O2>,
    Source: Copy, 

type Output = (O0, O1, O2)

type Pipe = (<R0 as ParallelSink<Source>>::Pipe, <R1 as ParallelSink<Source>>::Pipe, <R2 as ParallelSink<Source>>::Pipe)

type ReduceAFactory = ReduceA3Factory<<R0 as ParallelSink<Source>>::ReduceAFactory, <R1 as ParallelSink<Source>>::ReduceAFactory, <R2 as ParallelSink<Source>>::ReduceAFactory>

type ReduceA = ReduceA3<<R0 as ParallelSink<Source>>::ReduceA, <R1 as ParallelSink<Source>>::ReduceA, <R2 as ParallelSink<Source>>::ReduceA>

type ReduceC = ReduceC3<<R0 as ParallelSink<Source>>::ReduceC, <R1 as ParallelSink<Source>>::ReduceC, <R2 as ParallelSink<Source>>::ReduceC>

fn reducers(
    self
) -> (<(R0, R1, R2) as ParallelSink<Source>>::Pipe, <(R0, R1, R2) as ParallelSink<Source>>::ReduceAFactory, <(R0, R1, R2) as ParallelSink<Source>>::ReduceC)

impl<Source, R0, R1, R2, R3, R4, O0, O1, O2, O3, O4> ParallelSink<Source> for (R0, R1, R2, R3, R4) where
    R0: ParallelSink<Source, Output = O0>,
    R1: ParallelSink<Source, Output = O1>,
    R2: ParallelSink<Source, Output = O2>,
    R3: ParallelSink<Source, Output = O3>,
    R4: ParallelSink<Source, Output = O4>,
    Source: Copy, 

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

type Pipe = (<R0 as ParallelSink<Source>>::Pipe, <R1 as ParallelSink<Source>>::Pipe, <R2 as ParallelSink<Source>>::Pipe, <R3 as ParallelSink<Source>>::Pipe, <R4 as ParallelSink<Source>>::Pipe)

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

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

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

fn reducers(
    self
) -> (<(R0, R1, R2, R3, R4) as ParallelSink<Source>>::Pipe, <(R0, R1, R2, R3, R4) as ParallelSink<Source>>::ReduceAFactory, <(R0, R1, R2, R3, R4) as ParallelSink<Source>>::ReduceC)

impl<Source, R0, R1, O0, O1> ParallelSink<Source> for (R0, R1) where
    R0: ParallelSink<Source, Output = O0>,
    R1: ParallelSink<Source, Output = O1>,
    Source: Copy, 

type Output = (O0, O1)

type Pipe = (<R0 as ParallelSink<Source>>::Pipe, <R1 as ParallelSink<Source>>::Pipe)

type ReduceAFactory = ReduceA2Factory<<R0 as ParallelSink<Source>>::ReduceAFactory, <R1 as ParallelSink<Source>>::ReduceAFactory>

type ReduceA = ReduceA2<<R0 as ParallelSink<Source>>::ReduceA, <R1 as ParallelSink<Source>>::ReduceA>

type ReduceC = ReduceC2<<R0 as ParallelSink<Source>>::ReduceC, <R1 as ParallelSink<Source>>::ReduceC>

fn reducers(
    self
) -> (<(R0, R1) as ParallelSink<Source>>::Pipe, <(R0, R1) as ParallelSink<Source>>::ReduceAFactory, <(R0, R1) as ParallelSink<Source>>::ReduceC)

impl<Source, R0, R1, R2, R3, R4, R5, R6, O0, O1, O2, O3, O4, O5, O6> ParallelSink<Source> for (R0, R1, R2, R3, R4, R5, R6) where
    R0: ParallelSink<Source, Output = O0>,
    R1: ParallelSink<Source, Output = O1>,
    R2: ParallelSink<Source, Output = O2>,
    R3: ParallelSink<Source, Output = O3>,
    R4: ParallelSink<Source, Output = O4>,
    R5: ParallelSink<Source, Output = O5>,
    R6: ParallelSink<Source, Output = O6>,
    Source: Copy, 

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

type Pipe = (<R0 as ParallelSink<Source>>::Pipe, <R1 as ParallelSink<Source>>::Pipe, <R2 as ParallelSink<Source>>::Pipe, <R3 as ParallelSink<Source>>::Pipe, <R4 as ParallelSink<Source>>::Pipe, <R5 as ParallelSink<Source>>::Pipe, <R6 as ParallelSink<Source>>::Pipe)

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

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

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

fn reducers(
    self
) -> (<(R0, R1, R2, R3, R4, R5, R6) as ParallelSink<Source>>::Pipe, <(R0, R1, R2, R3, R4, R5, R6) as ParallelSink<Source>>::ReduceAFactory, <(R0, R1, R2, R3, R4, R5, R6) as ParallelSink<Source>>::ReduceC)

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

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

type Pipe = (<R0 as ParallelSink<Source>>::Pipe, <R1 as ParallelSink<Source>>::Pipe, <R2 as ParallelSink<Source>>::Pipe, <R3 as ParallelSink<Source>>::Pipe, <R4 as ParallelSink<Source>>::Pipe, <R5 as ParallelSink<Source>>::Pipe, <R6 as ParallelSink<Source>>::Pipe, <R7 as ParallelSink<Source>>::Pipe)

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

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

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

fn reducers(
    self
) -> (<(R0, R1, R2, R3, R4, R5, R6, R7) as ParallelSink<Source>>::Pipe, <(R0, R1, R2, R3, R4, R5, R6, R7) as ParallelSink<Source>>::ReduceAFactory, <(R0, R1, R2, R3, R4, R5, R6, R7) as ParallelSink<Source>>::ReduceC)

impl<Source, R0, O0> ParallelSink<Source> for (R0,) where
    R0: ParallelSink<Source, Output = O0>, 

type Output = (O0,)

type Pipe = (<R0 as ParallelSink<Source>>::Pipe,)

type ReduceAFactory = ReduceA1Factory<<R0 as ParallelSink<Source>>::ReduceAFactory>

type ReduceA = ReduceA1<<R0 as ParallelSink<Source>>::ReduceA>

type ReduceC = ReduceC1<<R0 as ParallelSink<Source>>::ReduceC>

fn reducers(
    self
) -> (<(R0,) as ParallelSink<Source>>::Pipe, <(R0,) as ParallelSink<Source>>::ReduceAFactory, <(R0,) as ParallelSink<Source>>::ReduceC)

impl<Source> ParallelSink<Source> for ()

type Output = ()

type Pipe = ()

type ReduceAFactory = ReduceA0Factory

type ReduceA = ReduceA0

type ReduceC = ReduceC0

fn reducers(
    self
) -> (<() as ParallelSink<Source>>::Pipe, <() as ParallelSink<Source>>::ReduceAFactory, <() as ParallelSink<Source>>::ReduceC)

Loading content...

Implementors

impl<A, B, Source> ParallelSink<Source> for Pipe<A, B> where
    A: ParallelPipe<Source>,
    B: ParallelSink<<A as ParallelPipe<Source>>::Item>, 

type Output = <B as ParallelSink<<A as ParallelPipe<Source>>::Item>>::Output

type Pipe = Pipe<A, <B as ParallelSink<<A as ParallelPipe<Source>>::Item>>::Pipe>

type ReduceAFactory = <B as ParallelSink<<A as ParallelPipe<Source>>::Item>>::ReduceAFactory

type ReduceA = <B as ParallelSink<<A as ParallelPipe<Source>>::Item>>::ReduceA

type ReduceC = <B as ParallelSink<<A as ParallelPipe<Source>>::Item>>::ReduceC

fn reducers(
    self
) -> (<Pipe<A, B> as ParallelSink<Source>>::Pipe, <Pipe<A, B> as ParallelSink<Source>>::ReduceAFactory, <Pipe<A, B> as ParallelSink<Source>>::ReduceC)

impl<I, Source> ParallelSink<Source> for Count<I> where
    I: ParallelPipe<Source>, 

type Output = <<Count<I> as ParallelSink<Source>>::ReduceC as Reducer>::Output

type Pipe = I

type ReduceAFactory = FolderSyncReducerFactory<<I as ParallelPipe<Source>>::Item, CountFolder>

type ReduceA = FolderSyncReducer<<I as ParallelPipe<Source>>::Item, CountFolder>

type ReduceC = FolderSyncReducer<<<Count<I> as ParallelSink<Source>>::ReduceA as Reducer>::Output, SumFolder<usize>>

fn reducers(
    self
) -> (I, <Count<I> as ParallelSink<Source>>::ReduceAFactory, <Count<I> as ParallelSink<Source>>::ReduceC)

impl<I, Source> ParallelSink<Source> for Histogram<I> where
    I: ParallelPipe<Source>,
    <I as ParallelPipe<Source>>::Item: Hash,
    <I as ParallelPipe<Source>>::Item: Ord,
    <I as ParallelPipe<Source>>::Item: Send,
    <I as ParallelPipe<Source>>::Item: 'static, 

type Output = <<Histogram<I> as ParallelSink<Source>>::ReduceC as Reducer>::Output

type Pipe = I

type ReduceAFactory = FolderSyncReducerFactory<<I as ParallelPipe<Source>>::Item, HistogramFolder<<I as ParallelPipe<Source>>::Item, StepA>>

type ReduceA = FolderSyncReducer<<I as ParallelPipe<Source>>::Item, HistogramFolder<<I as ParallelPipe<Source>>::Item, StepA>>

type ReduceC = FolderSyncReducer<<<Histogram<I> as ParallelSink<Source>>::ReduceA as Reducer>::Output, HistogramFolder<<I as ParallelPipe<Source>>::Item, StepB>>

fn reducers(
    self
) -> (I, <Histogram<I> as ParallelSink<Source>>::ReduceAFactory, <Histogram<I> as ParallelSink<Source>>::ReduceC)

impl<I, Source> ParallelSink<Source> for Max<I> where
    I: ParallelPipe<Source>,
    <I as ParallelPipe<Source>>::Item: Ord,
    <I as ParallelPipe<Source>>::Item: Send,
    <I as ParallelPipe<Source>>::Item: 'static, 

type Output = <<Max<I> as ParallelSink<Source>>::ReduceC as Reducer>::Output

type Pipe = I

type ReduceAFactory = FolderSyncReducerFactory<<I as ParallelPipe<Source>>::Item, Max<<I as ParallelPipe<Source>>::Item>>

type ReduceA = FolderSyncReducer<<I as ParallelPipe<Source>>::Item, Max<<I as ParallelPipe<Source>>::Item>>

type ReduceC = FolderSyncReducer<<<Max<I> as ParallelSink<Source>>::ReduceA as Reducer>::Output, Max<<I as ParallelPipe<Source>>::Item>>

fn reducers(
    self
) -> (I, <Max<I> as ParallelSink<Source>>::ReduceAFactory, <Max<I> as ParallelSink<Source>>::ReduceC)

impl<I, Source> ParallelSink<Source> for Min<I> where
    I: ParallelPipe<Source>,
    <I as ParallelPipe<Source>>::Item: Ord,
    <I as ParallelPipe<Source>>::Item: Send,
    <I as ParallelPipe<Source>>::Item: 'static, 

type Output = <<Min<I> as ParallelSink<Source>>::ReduceC as Reducer>::Output

type Pipe = I

type ReduceAFactory = FolderSyncReducerFactory<<I as ParallelPipe<Source>>::Item, Min<<I as ParallelPipe<Source>>::Item>>

type ReduceA = FolderSyncReducer<<I as ParallelPipe<Source>>::Item, Min<<I as ParallelPipe<Source>>::Item>>

type ReduceC = FolderSyncReducer<<<Min<I> as ParallelSink<Source>>::ReduceA as Reducer>::Output, Min<<I as ParallelPipe<Source>>::Item>>

fn reducers(
    self
) -> (I, <Min<I> as ParallelSink<Source>>::ReduceAFactory, <Min<I> as ParallelSink<Source>>::ReduceC)

impl<I, Source> ParallelSink<Source> for MostFrequent<I> where
    I: ParallelPipe<Source>,
    <I as ParallelPipe<Source>>::Item: Clone,
    <I as ParallelPipe<Source>>::Item: Hash,
    <I as ParallelPipe<Source>>::Item: Eq,
    <I as ParallelPipe<Source>>::Item: Send,
    <I as ParallelPipe<Source>>::Item: 'static, 

type Output = <<MostFrequent<I> as ParallelSink<Source>>::ReduceC as Reducer>::Output

type Pipe = I

type ReduceAFactory = FolderSyncReducerFactory<<I as ParallelPipe<Source>>::Item, MostFrequentFolder>

type ReduceA = FolderSyncReducer<<I as ParallelPipe<Source>>::Item, MostFrequentFolder>

type ReduceC = FolderSyncReducer<<<MostFrequent<I> as ParallelSink<Source>>::ReduceA as Reducer>::Output, SumZeroFolder<Top<<I as ParallelPipe<Source>>::Item, usize>>>

fn reducers(
    self
) -> (I, <MostFrequent<I> as ParallelSink<Source>>::ReduceAFactory, <MostFrequent<I> as ParallelSink<Source>>::ReduceC)

impl<I, Source> ParallelSink<Source> for SampleUnstable<I> where
    I: ParallelPipe<Source>,
    <I as ParallelPipe<Source>>::Item: Send,
    <I as ParallelPipe<Source>>::Item: 'static, 

type Output = <<SampleUnstable<I> as ParallelSink<Source>>::ReduceC as Reducer>::Output

type Pipe = I

type ReduceAFactory = FolderSyncReducerFactory<<I as ParallelPipe<Source>>::Item, SampleUnstableFolder>

type ReduceA = FolderSyncReducer<<I as ParallelPipe<Source>>::Item, SampleUnstableFolder>

type ReduceC = FolderSyncReducer<<<SampleUnstable<I> as ParallelSink<Source>>::ReduceA as Reducer>::Output, SumFolder<SampleUnstable<<I as ParallelPipe<Source>>::Item>>>

fn reducers(
    self
) -> (I, <SampleUnstable<I> as ParallelSink<Source>>::ReduceAFactory, <SampleUnstable<I> as ParallelSink<Source>>::ReduceC)

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

type Output = <<MostDistinct<I> as ParallelSink<Source>>::ReduceC as Reducer>::Output

type Pipe = I

type ReduceAFactory = FolderSyncReducerFactory<<I as ParallelPipe<Source>>::Item, MostDistinctFolder>

type ReduceA = FolderSyncReducer<<I as ParallelPipe<Source>>::Item, MostDistinctFolder>

type ReduceC = FolderSyncReducer<<<MostDistinct<I> as ParallelSink<Source>>::ReduceA as Reducer>::Output, SumZeroFolder<Top<A, HyperLogLogMagnitude<B>>>>

fn reducers(
    self
) -> (I, <MostDistinct<I> as ParallelSink<Source>>::ReduceAFactory, <MostDistinct<I> as ParallelSink<Source>>::ReduceC)

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

type Output = <<GroupBy<I, ID, F, C> as ParallelSink<Source>>::ReduceC as Reducer>::Output

type Pipe = I

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

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

type ReduceC = FolderSyncReducer<<<GroupBy<I, ID, F, C> as ParallelSink<Source>>::ReduceA as Reducer>::Output, GroupByFolder<A, B, ID, F, C, StepB>>

fn reducers(
    self
) -> (I, <GroupBy<I, ID, F, C> as ParallelSink<Source>>::ReduceAFactory, <GroupBy<I, ID, F, C> as ParallelSink<Source>>::ReduceC)

impl<I, Source, B> ParallelSink<Source> for Sum<I, B> where
    B: Sum<<I as ParallelPipe<Source>>::Item> + Sum<B> + Send + 'static,
    I: ParallelPipe<Source>, 

type Output = <<Sum<I, B> as ParallelSink<Source>>::ReduceC as Reducer>::Output

type Pipe = I

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

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

type ReduceC = FolderSyncReducer<<<Sum<I, B> as ParallelSink<Source>>::ReduceA as Reducer>::Output, SumFolder<B>>

fn reducers(
    self
) -> (I, <Sum<I, B> as ParallelSink<Source>>::ReduceAFactory, <Sum<I, B> as ParallelSink<Source>>::ReduceC)

impl<I, Source, F> ParallelSink<Source> for All<I, F> where
    F: FnMut(<I as ParallelPipe<Source>>::Item) -> bool + Clone + Send + 'static,
    I: ParallelPipe<Source>, 

type Output = bool

type Pipe = I

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

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

type ReduceC = BoolAndReducer

fn reducers(
    self
) -> (<All<I, F> as ParallelSink<Source>>::Pipe, <All<I, F> as ParallelSink<Source>>::ReduceAFactory, <All<I, F> as ParallelSink<Source>>::ReduceC)

impl<I, Source, F> ParallelSink<Source> for Any<I, F> where
    F: FnMut(<I as ParallelPipe<Source>>::Item) -> bool + Clone + Send + 'static,
    I: ParallelPipe<Source>, 

type Output = bool

type Pipe = I

type ReduceAFactory = AnyReducerFactory<<I as ParallelPipe<Source>>::Item, F>

type ReduceA = AnyReducer<<I as ParallelPipe<Source>>::Item, F>

type ReduceC = BoolOrReducer

fn reducers(
    self
) -> (<Any<I, F> as ParallelSink<Source>>::Pipe, <Any<I, F> as ParallelSink<Source>>::ReduceAFactory, <Any<I, F> as ParallelSink<Source>>::ReduceC)

impl<I, Source, F> ParallelSink<Source> for Combine<I, F> where
    F: FnMut(<I as ParallelPipe<Source>>::Item, <I as ParallelPipe<Source>>::Item) -> <I as ParallelPipe<Source>>::Item + Clone + Send + 'static,
    I: ParallelPipe<Source>,
    <I as ParallelPipe<Source>>::Item: Send,
    <I as ParallelPipe<Source>>::Item: 'static, 

type Output = <<Combine<I, F> as ParallelSink<Source>>::ReduceC as Reducer>::Output

type Pipe = I

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

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

type ReduceC = FolderSyncReducer<<<Combine<I, F> as ParallelSink<Source>>::ReduceA as Reducer>::Output, ReduceFn<F, <I as ParallelPipe<Source>>::Item>>

fn reducers(
    self
) -> (I, <Combine<I, F> as ParallelSink<Source>>::ReduceAFactory, <Combine<I, F> as ParallelSink<Source>>::ReduceC)

impl<I, Source, F> ParallelSink<Source> for ForEach<I, F> where
    F: FnMut(<I as ParallelPipe<Source>>::Item) + Clone + Send + 'static,
    I: ParallelPipe<Source>, 

type Output = ()

type Pipe = I

type ReduceAFactory = ForEachReducerFactory<<I as ParallelPipe<Source>>::Item, F>

type ReduceA = ForEachReducer<<I as ParallelPipe<Source>>::Item, F>

type ReduceC = PushReducer<(), ()>

fn reducers(
    self
) -> (<ForEach<I, F> as ParallelSink<Source>>::Pipe, <ForEach<I, F> as ParallelSink<Source>>::ReduceAFactory, <ForEach<I, F> as ParallelSink<Source>>::ReduceC)

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

type Output = <<MaxBy<I, F> as ParallelSink<Source>>::ReduceC as Reducer>::Output

type Pipe = I

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

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

type ReduceC = FolderSyncReducer<<<MaxBy<I, F> as ParallelSink<Source>>::ReduceA as Reducer>::Output, MaxBy<<I as ParallelPipe<Source>>::Item, F>>

fn reducers(
    self
) -> (I, <MaxBy<I, F> as ParallelSink<Source>>::ReduceAFactory, <MaxBy<I, F> as ParallelSink<Source>>::ReduceC)

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

type Output = <<MinBy<I, F> as ParallelSink<Source>>::ReduceC as Reducer>::Output

type Pipe = I

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

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

type ReduceC = FolderSyncReducer<<<MinBy<I, F> as ParallelSink<Source>>::ReduceA as Reducer>::Output, MinBy<<I as ParallelPipe<Source>>::Item, F>>

fn reducers(
    self
) -> (I, <MinBy<I, F> as ParallelSink<Source>>::ReduceAFactory, <MinBy<I, F> as ParallelSink<Source>>::ReduceC)

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

type Output = <<MaxByKey<I, F> as ParallelSink<Source>>::ReduceC as Reducer>::Output

type Pipe = I

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

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

type ReduceC = FolderSyncReducer<<<MaxByKey<I, F> as ParallelSink<Source>>::ReduceA as Reducer>::Output, MaxByKey<<I as ParallelPipe<Source>>::Item, F, B>>

fn reducers(
    self
) -> (I, <MaxByKey<I, F> as ParallelSink<Source>>::ReduceAFactory, <MaxByKey<I, F> as ParallelSink<Source>>::ReduceC)

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

type Output = <<MinByKey<I, F> as ParallelSink<Source>>::ReduceC as Reducer>::Output

type Pipe = I

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

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

type ReduceC = FolderSyncReducer<<<MinByKey<I, F> as ParallelSink<Source>>::ReduceA as Reducer>::Output, MinByKey<<I as ParallelPipe<Source>>::Item, F, B>>

fn reducers(
    self
) -> (I, <MinByKey<I, F> as ParallelSink<Source>>::ReduceAFactory, <MinByKey<I, F> as ParallelSink<Source>>::ReduceC)

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

type Output = <<Fold<I, ID, F, B> as ParallelSink<Source>>::ReduceC as Reducer>::Output

type Pipe = I

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

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

type ReduceC = FolderSyncReducer<<<Fold<I, ID, F, B> as ParallelSink<Source>>::ReduceA as Reducer>::Output, FoldFolder<<I as ParallelPipe<Source>>::Item, ID, F, B, StepB>>

fn reducers(
    self
) -> (I, <Fold<I, ID, F, B> as ParallelSink<Source>>::ReduceAFactory, <Fold<I, ID, F, B> as ParallelSink<Source>>::ReduceC)

impl<I, Source, T> ParallelSink<Source> for Collect<I, T> where
    I: ParallelPipe<Source>,
    T: FromParallelStream<<I as ParallelPipe<Source>>::Item>, 

type Output = T

type Pipe = I

type ReduceAFactory = <T as FromParallelStream<<I as ParallelPipe<Source>>::Item>>::ReduceAFactory

type ReduceA = <T as FromParallelStream<<I as ParallelPipe<Source>>::Item>>::ReduceA

type ReduceC = <T as FromParallelStream<<I as ParallelPipe<Source>>::Item>>::ReduceC

fn reducers(
    self
) -> (<Collect<I, T> as ParallelSink<Source>>::Pipe, <Collect<I, T> as ParallelSink<Source>>::ReduceAFactory, <Collect<I, T> as ParallelSink<Source>>::ReduceC)

Loading content...