Trait amadeus::par_sink::DistributedSink

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

Associated Types

type Done

type Pipe: DistributedPipe<Item>

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

type ReduceB: ReducerProcessSend<<Self::ReduceA as ReducerSend<<Self::Pipe as DistributedPipe<Item>>::Output>>::Done> + ProcessSend + Clone

type ReduceC: Reducer<<Self::ReduceB as ReducerProcessSend<<Self::ReduceA as ReducerSend<<Self::Pipe as DistributedPipe<Item>>::Output>>::Done>>::Done>

Loading content...

Required methods

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

Loading content...

Implementations on Foreign Types

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

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

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

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

type ReduceB = ReduceC6<<R0 as DistributedSink<Item>>::ReduceB, <R1 as DistributedSink<Item>>::ReduceB, <R2 as DistributedSink<Item>>::ReduceB, <R3 as DistributedSink<Item>>::ReduceB, <R4 as DistributedSink<Item>>::ReduceB, <R5 as DistributedSink<Item>>::ReduceB>

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

fn reducers(
    self
) -> (<(R0, R1, R2, R3, R4, R5) as DistributedSink<Item>>::Pipe, <(R0, R1, R2, R3, R4, R5) as DistributedSink<Item>>::ReduceA, <(R0, R1, R2, R3, R4, R5) as DistributedSink<Item>>::ReduceB, <(R0, R1, R2, R3, R4, R5) as DistributedSink<Item>>::ReduceC)

impl<Item, R0, O0> DistributedSink<Item> for (R0,) where
    R0: DistributedSink<Item, Done = O0>, 

type Done = (O0,)

type Pipe = (<R0 as DistributedSink<Item>>::Pipe,)

type ReduceA = ReduceA1<<R0 as DistributedSink<Item>>::ReduceA>

type ReduceB = ReduceC1<<R0 as DistributedSink<Item>>::ReduceB>

type ReduceC = ReduceC1<<R0 as DistributedSink<Item>>::ReduceC>

fn reducers(
    self
) -> (<(R0,) as DistributedSink<Item>>::Pipe, <(R0,) as DistributedSink<Item>>::ReduceA, <(R0,) as DistributedSink<Item>>::ReduceB, <(R0,) as DistributedSink<Item>>::ReduceC)

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

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

type Pipe = (<R0 as DistributedSink<Item>>::Pipe, <R1 as DistributedSink<Item>>::Pipe, <R2 as DistributedSink<Item>>::Pipe, <R3 as DistributedSink<Item>>::Pipe, <R4 as DistributedSink<Item>>::Pipe)

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

type ReduceB = ReduceC5<<R0 as DistributedSink<Item>>::ReduceB, <R1 as DistributedSink<Item>>::ReduceB, <R2 as DistributedSink<Item>>::ReduceB, <R3 as DistributedSink<Item>>::ReduceB, <R4 as DistributedSink<Item>>::ReduceB>

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

fn reducers(
    self
) -> (<(R0, R1, R2, R3, R4) as DistributedSink<Item>>::Pipe, <(R0, R1, R2, R3, R4) as DistributedSink<Item>>::ReduceA, <(R0, R1, R2, R3, R4) as DistributedSink<Item>>::ReduceB, <(R0, R1, R2, R3, R4) as DistributedSink<Item>>::ReduceC)

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

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

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

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

type ReduceB = ReduceC7<<R0 as DistributedSink<Item>>::ReduceB, <R1 as DistributedSink<Item>>::ReduceB, <R2 as DistributedSink<Item>>::ReduceB, <R3 as DistributedSink<Item>>::ReduceB, <R4 as DistributedSink<Item>>::ReduceB, <R5 as DistributedSink<Item>>::ReduceB, <R6 as DistributedSink<Item>>::ReduceB>

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

fn reducers(
    self
) -> (<(R0, R1, R2, R3, R4, R5, R6) as DistributedSink<Item>>::Pipe, <(R0, R1, R2, R3, R4, R5, R6) as DistributedSink<Item>>::ReduceA, <(R0, R1, R2, R3, R4, R5, R6) as DistributedSink<Item>>::ReduceB, <(R0, R1, R2, R3, R4, R5, R6) as DistributedSink<Item>>::ReduceC)

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

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

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

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

type ReduceB = ReduceC8<<R0 as DistributedSink<Item>>::ReduceB, <R1 as DistributedSink<Item>>::ReduceB, <R2 as DistributedSink<Item>>::ReduceB, <R3 as DistributedSink<Item>>::ReduceB, <R4 as DistributedSink<Item>>::ReduceB, <R5 as DistributedSink<Item>>::ReduceB, <R6 as DistributedSink<Item>>::ReduceB, <R7 as DistributedSink<Item>>::ReduceB>

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

fn reducers(
    self
) -> (<(R0, R1, R2, R3, R4, R5, R6, R7) as DistributedSink<Item>>::Pipe, <(R0, R1, R2, R3, R4, R5, R6, R7) as DistributedSink<Item>>::ReduceA, <(R0, R1, R2, R3, R4, R5, R6, R7) as DistributedSink<Item>>::ReduceB, <(R0, R1, R2, R3, R4, R5, R6, R7) as DistributedSink<Item>>::ReduceC)

impl<Item> DistributedSink<Item> for ()

type Done = ()

type Pipe = ()

type ReduceA = ReduceA0

type ReduceB = ReduceC0

type ReduceC = ReduceC0

fn reducers(
    self
) -> (<() as DistributedSink<Item>>::Pipe, <() as DistributedSink<Item>>::ReduceA, <() as DistributedSink<Item>>::ReduceB, <() as DistributedSink<Item>>::ReduceC)

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

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

type Pipe = (<R0 as DistributedSink<Item>>::Pipe, <R1 as DistributedSink<Item>>::Pipe, <R2 as DistributedSink<Item>>::Pipe, <R3 as DistributedSink<Item>>::Pipe)

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

type ReduceB = ReduceC4<<R0 as DistributedSink<Item>>::ReduceB, <R1 as DistributedSink<Item>>::ReduceB, <R2 as DistributedSink<Item>>::ReduceB, <R3 as DistributedSink<Item>>::ReduceB>

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

fn reducers(
    self
) -> (<(R0, R1, R2, R3) as DistributedSink<Item>>::Pipe, <(R0, R1, R2, R3) as DistributedSink<Item>>::ReduceA, <(R0, R1, R2, R3) as DistributedSink<Item>>::ReduceB, <(R0, R1, R2, R3) as DistributedSink<Item>>::ReduceC)

impl<Item, R0, R1, R2, O0, O1, O2> DistributedSink<Item> for (R0, R1, R2) where
    Item: Copy,
    R0: DistributedSink<Item, Done = O0>,
    R1: DistributedSink<Item, Done = O1>,
    R2: DistributedSink<Item, Done = O2>, 

type Done = (O0, O1, O2)

type Pipe = (<R0 as DistributedSink<Item>>::Pipe, <R1 as DistributedSink<Item>>::Pipe, <R2 as DistributedSink<Item>>::Pipe)

type ReduceA = ReduceA3<<R0 as DistributedSink<Item>>::ReduceA, <R1 as DistributedSink<Item>>::ReduceA, <R2 as DistributedSink<Item>>::ReduceA>

type ReduceB = ReduceC3<<R0 as DistributedSink<Item>>::ReduceB, <R1 as DistributedSink<Item>>::ReduceB, <R2 as DistributedSink<Item>>::ReduceB>

type ReduceC = ReduceC3<<R0 as DistributedSink<Item>>::ReduceC, <R1 as DistributedSink<Item>>::ReduceC, <R2 as DistributedSink<Item>>::ReduceC>

fn reducers(
    self
) -> (<(R0, R1, R2) as DistributedSink<Item>>::Pipe, <(R0, R1, R2) as DistributedSink<Item>>::ReduceA, <(R0, R1, R2) as DistributedSink<Item>>::ReduceB, <(R0, R1, R2) as DistributedSink<Item>>::ReduceC)

impl<Item, R0, R1, O0, O1> DistributedSink<Item> for (R0, R1) where
    Item: Copy,
    R0: DistributedSink<Item, Done = O0>,
    R1: DistributedSink<Item, Done = O1>, 

type Done = (O0, O1)

type Pipe = (<R0 as DistributedSink<Item>>::Pipe, <R1 as DistributedSink<Item>>::Pipe)

type ReduceA = ReduceA2<<R0 as DistributedSink<Item>>::ReduceA, <R1 as DistributedSink<Item>>::ReduceA>

type ReduceB = ReduceC2<<R0 as DistributedSink<Item>>::ReduceB, <R1 as DistributedSink<Item>>::ReduceB>

type ReduceC = ReduceC2<<R0 as DistributedSink<Item>>::ReduceC, <R1 as DistributedSink<Item>>::ReduceC>

fn reducers(
    self
) -> (<(R0, R1) as DistributedSink<Item>>::Pipe, <(R0, R1) as DistributedSink<Item>>::ReduceA, <(R0, R1) as DistributedSink<Item>>::ReduceB, <(R0, R1) as DistributedSink<Item>>::ReduceC)

Loading content...

Implementors

impl<A, B, C, Item, RefAItem> DistributedSink<Item> for Fork<A, B, C, RefAItem> where
    A: DistributedPipe<Item>,
    B: DistributedSink<<A as DistributedPipe<Item>>::Output>,
    C: DistributedSink<RefAItem>,
    RefAItem: 'static, 

type Done = (<B as DistributedSink<<A as DistributedPipe<Item>>::Output>>::Done, <C as DistributedSink<RefAItem>>::Done)

type Pipe = Fork<A, <B as DistributedSink<<A as DistributedPipe<Item>>::Output>>::Pipe, <C as DistributedSink<RefAItem>>::Pipe, RefAItem>

type ReduceA = ReduceA2<<B as DistributedSink<<A as DistributedPipe<Item>>::Output>>::ReduceA, <C as DistributedSink<RefAItem>>::ReduceA>

type ReduceB = ReduceC2<<B as DistributedSink<<A as DistributedPipe<Item>>::Output>>::ReduceB, <C as DistributedSink<RefAItem>>::ReduceB>

type ReduceC = ReduceC2<<B as DistributedSink<<A as DistributedPipe<Item>>::Output>>::ReduceC, <C as DistributedSink<RefAItem>>::ReduceC>

fn reducers(
    self
) -> (<Fork<A, B, C, RefAItem> as DistributedSink<Item>>::Pipe, <Fork<A, B, C, RefAItem> as DistributedSink<Item>>::ReduceA, <Fork<A, B, C, RefAItem> as DistributedSink<Item>>::ReduceB, <Fork<A, B, C, RefAItem> as DistributedSink<Item>>::ReduceC)

impl<A, B, Item> DistributedSink<Item> for Pipe<A, B> where
    A: DistributedPipe<Item>,
    B: DistributedSink<<A as DistributedPipe<Item>>::Output>, 

type Done = <B as DistributedSink<<A as DistributedPipe<Item>>::Output>>::Done

type Pipe = Pipe<A, <B as DistributedSink<<A as DistributedPipe<Item>>::Output>>::Pipe>

type ReduceA = <B as DistributedSink<<A as DistributedPipe<Item>>::Output>>::ReduceA

type ReduceB = <B as DistributedSink<<A as DistributedPipe<Item>>::Output>>::ReduceB

type ReduceC = <B as DistributedSink<<A as DistributedPipe<Item>>::Output>>::ReduceC

fn reducers(
    self
) -> (<Pipe<A, B> as DistributedSink<Item>>::Pipe, <Pipe<A, B> as DistributedSink<Item>>::ReduceA, <Pipe<A, B> as DistributedSink<Item>>::ReduceB, <Pipe<A, B> as DistributedSink<Item>>::ReduceC)

impl<A, B, Item, T, U> DistributedSink<Item> for GroupBy<A, B> where
    A: DistributedPipe<Item, Output = (T, U)>,
    B: DistributedSink<U>,
    T: Eq + Hash + ProcessSend + 'static,
    <<B as DistributedSink<U>>::Pipe as DistributedPipe<U>>::Task: Clone,
    <<B as DistributedSink<U>>::Pipe as DistributedPipe<U>>::Task: ProcessSend,
    <<B as DistributedSink<U>>::Pipe as DistributedPipe<U>>::Task: 'static,
    <B as DistributedSink<U>>::ReduceA: Clone,
    <B as DistributedSink<U>>::ReduceA: ProcessSend,
    <B as DistributedSink<U>>::ReduceA: 'static,
    <B as DistributedSink<U>>::ReduceB: Clone,
    <B as DistributedSink<U>>::ReduceC: Clone,
    <B as DistributedSink<U>>::Done: ProcessSend,
    <B as DistributedSink<U>>::Done: 'static, 

type Done = IndexMap<T, <B as DistributedSink<U>>::Done, RandomState>

type Pipe = A

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

type ReduceB = GroupByReducerB<<B as DistributedSink<U>>::ReduceB, T, <<B as DistributedSink<U>>::ReduceA as ReducerSend<<<B as DistributedSink<U>>::Pipe as DistributedPipe<U>>::Output>>::Done>

type ReduceC = GroupByReducerB<<B as DistributedSink<U>>::ReduceC, T, <<B as DistributedSink<U>>::ReduceB as ReducerProcessSend<<<B as DistributedSink<U>>::ReduceA as Reducer<<<B as DistributedSink<U>>::Pipe as DistributedPipe<U>>::Output>>::Done>>::Done>

fn reducers(
    self
) -> (<GroupBy<A, B> as DistributedSink<Item>>::Pipe, <GroupBy<A, B> as DistributedSink<Item>>::ReduceA, <GroupBy<A, B> as DistributedSink<Item>>::ReduceB, <GroupBy<A, B> as DistributedSink<Item>>::ReduceC)

impl<P, Item> DistributedSink<Item> for Count<P> where
    P: DistributedPipe<Item>, 

type Done = <<Count<P> as DistributedSink<Item>>::ReduceC as Reducer<<<Count<P> as DistributedSink<Item>>::ReduceB as Reducer<<<Count<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<<P as DistributedPipe<Item>>::Output, CountFolder>

type ReduceB = FolderSyncReducer<<<Count<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done, SumFolder<usize>>

type ReduceC = FolderSyncReducer<<<Count<P> as DistributedSink<Item>>::ReduceB as Reducer<<<Count<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done, SumFolder<usize>>

fn reducers(
    self
) -> (P, <Count<P> as DistributedSink<Item>>::ReduceA, <Count<P> as DistributedSink<Item>>::ReduceB, <Count<P> as DistributedSink<Item>>::ReduceC)

impl<P, Item> DistributedSink<Item> for Histogram<P> where
    P: DistributedPipe<Item>,
    <P as DistributedPipe<Item>>::Output: Hash,
    <P as DistributedPipe<Item>>::Output: Ord,
    <P as DistributedPipe<Item>>::Output: ProcessSend,
    <P as DistributedPipe<Item>>::Output: 'static, 

type Done = <<Histogram<P> as DistributedSink<Item>>::ReduceC as Reducer<<<Histogram<P> as DistributedSink<Item>>::ReduceB as Reducer<<<Histogram<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<<P as DistributedPipe<Item>>::Output, HistogramFolder<<P as DistributedPipe<Item>>::Output, StepA>>

type ReduceB = FolderSyncReducer<<<Histogram<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done, HistogramFolder<<P as DistributedPipe<Item>>::Output, StepB>>

type ReduceC = FolderSyncReducer<<<Histogram<P> as DistributedSink<Item>>::ReduceB as Reducer<<<Histogram<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done, HistogramFolder<<P as DistributedPipe<Item>>::Output, StepB>>

fn reducers(
    self
) -> (P, <Histogram<P> as DistributedSink<Item>>::ReduceA, <Histogram<P> as DistributedSink<Item>>::ReduceB, <Histogram<P> as DistributedSink<Item>>::ReduceC)

impl<P, Item> DistributedSink<Item> for Max<P> where
    P: DistributedPipe<Item>,
    <P as DistributedPipe<Item>>::Output: Ord,
    <P as DistributedPipe<Item>>::Output: ProcessSend,
    <P as DistributedPipe<Item>>::Output: 'static, 

type Done = <<Max<P> as DistributedSink<Item>>::ReduceC as Reducer<<<Max<P> as DistributedSink<Item>>::ReduceB as Reducer<<<Max<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<<P as DistributedPipe<Item>>::Output, Max<<P as DistributedPipe<Item>>::Output>>

type ReduceB = FolderSyncReducer<<<Max<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done, Max<<P as DistributedPipe<Item>>::Output>>

type ReduceC = FolderSyncReducer<<<Max<P> as DistributedSink<Item>>::ReduceB as Reducer<<<Max<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done, Max<<P as DistributedPipe<Item>>::Output>>

fn reducers(
    self
) -> (P, <Max<P> as DistributedSink<Item>>::ReduceA, <Max<P> as DistributedSink<Item>>::ReduceB, <Max<P> as DistributedSink<Item>>::ReduceC)

impl<P, Item> DistributedSink<Item> for Min<P> where
    P: DistributedPipe<Item>,
    <P as DistributedPipe<Item>>::Output: Ord,
    <P as DistributedPipe<Item>>::Output: ProcessSend,
    <P as DistributedPipe<Item>>::Output: 'static, 

type Done = <<Min<P> as DistributedSink<Item>>::ReduceC as Reducer<<<Min<P> as DistributedSink<Item>>::ReduceB as Reducer<<<Min<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<<P as DistributedPipe<Item>>::Output, Min<<P as DistributedPipe<Item>>::Output>>

type ReduceB = FolderSyncReducer<<<Min<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done, Min<<P as DistributedPipe<Item>>::Output>>

type ReduceC = FolderSyncReducer<<<Min<P> as DistributedSink<Item>>::ReduceB as Reducer<<<Min<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done, Min<<P as DistributedPipe<Item>>::Output>>

fn reducers(
    self
) -> (P, <Min<P> as DistributedSink<Item>>::ReduceA, <Min<P> as DistributedSink<Item>>::ReduceB, <Min<P> as DistributedSink<Item>>::ReduceC)

impl<P, Item> DistributedSink<Item> for MostFrequent<P> where
    P: DistributedPipe<Item>,
    <P as DistributedPipe<Item>>::Output: Clone,
    <P as DistributedPipe<Item>>::Output: Hash,
    <P as DistributedPipe<Item>>::Output: Eq,
    <P as DistributedPipe<Item>>::Output: ProcessSend,
    <P as DistributedPipe<Item>>::Output: 'static, 

type Done = <<MostFrequent<P> as DistributedSink<Item>>::ReduceC as Reducer<<<MostFrequent<P> as DistributedSink<Item>>::ReduceB as Reducer<<<MostFrequent<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<<P as DistributedPipe<Item>>::Output, MostFrequentFolder>

type ReduceB = FolderSyncReducer<<<MostFrequent<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done, SumZeroFolder<Top<<P as DistributedPipe<Item>>::Output, usize>>>

type ReduceC = FolderSyncReducer<<<MostFrequent<P> as DistributedSink<Item>>::ReduceB as Reducer<<<MostFrequent<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done, SumZeroFolder<Top<<P as DistributedPipe<Item>>::Output, usize>>>

fn reducers(
    self
) -> (P, <MostFrequent<P> as DistributedSink<Item>>::ReduceA, <MostFrequent<P> as DistributedSink<Item>>::ReduceB, <MostFrequent<P> as DistributedSink<Item>>::ReduceC)

impl<P, Item> DistributedSink<Item> for SampleUnstable<P> where
    P: DistributedPipe<Item>,
    <P as DistributedPipe<Item>>::Output: ProcessSend,
    <P as DistributedPipe<Item>>::Output: 'static, 

type Done = <<SampleUnstable<P> as DistributedSink<Item>>::ReduceC as Reducer<<<SampleUnstable<P> as DistributedSink<Item>>::ReduceB as Reducer<<<SampleUnstable<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<<P as DistributedPipe<Item>>::Output, SampleUnstableFolder>

type ReduceB = FolderSyncReducer<<<SampleUnstable<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done, SumFolder<SampleUnstable<<P as DistributedPipe<Item>>::Output>>>

type ReduceC = FolderSyncReducer<<<SampleUnstable<P> as DistributedSink<Item>>::ReduceB as Reducer<<<SampleUnstable<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done, SumFolder<SampleUnstable<<P as DistributedPipe<Item>>::Output>>>

fn reducers(
    self
) -> (P, <SampleUnstable<P> as DistributedSink<Item>>::ReduceA, <SampleUnstable<P> as DistributedSink<Item>>::ReduceB, <SampleUnstable<P> as DistributedSink<Item>>::ReduceC)

impl<P, Item, A, B> DistributedSink<Item> for MostDistinct<P> where
    A: Clone + Hash + Eq + ProcessSend + 'static,
    B: Hash + 'static,
    P: DistributedPipe<Item, Output = (A, B)>, 

type Done = <<MostDistinct<P> as DistributedSink<Item>>::ReduceC as Reducer<<<MostDistinct<P> as DistributedSink<Item>>::ReduceB as Reducer<<<MostDistinct<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<<P as DistributedPipe<Item>>::Output, MostDistinctFolder>

type ReduceB = FolderSyncReducer<<<MostDistinct<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done, SumZeroFolder<Top<A, HyperLogLogMagnitude<B>>>>

type ReduceC = FolderSyncReducer<<<MostDistinct<P> as DistributedSink<Item>>::ReduceB as Reducer<<<MostDistinct<P> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done, SumZeroFolder<Top<A, HyperLogLogMagnitude<B>>>>

fn reducers(
    self
) -> (P, <MostDistinct<P> as DistributedSink<Item>>::ReduceA, <MostDistinct<P> as DistributedSink<Item>>::ReduceB, <MostDistinct<P> as DistributedSink<Item>>::ReduceC)

impl<P, Item, B> DistributedSink<Item> for Sum<P, B> where
    B: Sum<<P as DistributedPipe<Item>>::Output> + Sum<B> + ProcessSend + 'static,
    P: DistributedPipe<Item>, 

type Done = <<Sum<P, B> as DistributedSink<Item>>::ReduceC as Reducer<<<Sum<P, B> as DistributedSink<Item>>::ReduceB as Reducer<<<Sum<P, B> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<<P as DistributedPipe<Item>>::Output, SumFolder<B>>

type ReduceB = FolderSyncReducer<<<Sum<P, B> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done, SumFolder<B>>

type ReduceC = FolderSyncReducer<<<Sum<P, B> as DistributedSink<Item>>::ReduceB as Reducer<<<Sum<P, B> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done, SumFolder<B>>

fn reducers(
    self
) -> (P, <Sum<P, B> as DistributedSink<Item>>::ReduceA, <Sum<P, B> as DistributedSink<Item>>::ReduceB, <Sum<P, B> as DistributedSink<Item>>::ReduceC)

impl<P, Item, F> DistributedSink<Item> for All<P, F> where
    F: FnMut<(<P as DistributedPipe<Item>>::Output,), Output = bool> + Clone + ProcessSend + 'static,
    P: DistributedPipe<Item>, 

type Done = bool

type Pipe = P

type ReduceA = AllReducer<<P as DistributedPipe<Item>>::Output, F>

type ReduceB = BoolAndReducer

type ReduceC = BoolAndReducer

fn reducers(
    self
) -> (<All<P, F> as DistributedSink<Item>>::Pipe, <All<P, F> as DistributedSink<Item>>::ReduceA, <All<P, F> as DistributedSink<Item>>::ReduceB, <All<P, F> as DistributedSink<Item>>::ReduceC)

impl<P, Item, F> DistributedSink<Item> for Any<P, F> where
    F: FnMut<(<P as DistributedPipe<Item>>::Output,), Output = bool> + Clone + ProcessSend + 'static,
    P: DistributedPipe<Item>, 

type Done = bool

type Pipe = P

type ReduceA = AnyReducer<<P as DistributedPipe<Item>>::Output, F>

type ReduceB = BoolOrReducer

type ReduceC = BoolOrReducer

fn reducers(
    self
) -> (<Any<P, F> as DistributedSink<Item>>::Pipe, <Any<P, F> as DistributedSink<Item>>::ReduceA, <Any<P, F> as DistributedSink<Item>>::ReduceB, <Any<P, F> as DistributedSink<Item>>::ReduceC)

impl<P, Item, F> DistributedSink<Item> for Combine<P, F> where
    F: FnMut<(<P as DistributedPipe<Item>>::Output, <P as DistributedPipe<Item>>::Output), Output = <P as DistributedPipe<Item>>::Output> + Clone + ProcessSend + 'static,
    P: DistributedPipe<Item>,
    <P as DistributedPipe<Item>>::Output: ProcessSend,
    <P as DistributedPipe<Item>>::Output: 'static, 

type Done = <<Combine<P, F> as DistributedSink<Item>>::ReduceC as Reducer<<<Combine<P, F> as DistributedSink<Item>>::ReduceB as Reducer<<<Combine<P, F> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<<P as DistributedPipe<Item>>::Output, ReduceFn<F, <P as DistributedPipe<Item>>::Output>>

type ReduceB = FolderSyncReducer<<<Combine<P, F> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done, ReduceFn<F, <P as DistributedPipe<Item>>::Output>>

type ReduceC = FolderSyncReducer<<<Combine<P, F> as DistributedSink<Item>>::ReduceB as Reducer<<<Combine<P, F> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done, ReduceFn<F, <P as DistributedPipe<Item>>::Output>>

fn reducers(
    self
) -> (P, <Combine<P, F> as DistributedSink<Item>>::ReduceA, <Combine<P, F> as DistributedSink<Item>>::ReduceB, <Combine<P, F> as DistributedSink<Item>>::ReduceC)

impl<P, Item, F> DistributedSink<Item> for ForEach<P, F> where
    F: FnMut<(<P as DistributedPipe<Item>>::Output,), Output = ()> + Clone + ProcessSend + 'static,
    P: DistributedPipe<Item>, 

type Done = ()

type Pipe = P

type ReduceA = ForEachReducer<<P as DistributedPipe<Item>>::Output, F>

type ReduceB = PushReducer<(), ()>

type ReduceC = PushReducer<(), ()>

fn reducers(
    self
) -> (<ForEach<P, F> as DistributedSink<Item>>::Pipe, <ForEach<P, F> as DistributedSink<Item>>::ReduceA, <ForEach<P, F> as DistributedSink<Item>>::ReduceB, <ForEach<P, F> as DistributedSink<Item>>::ReduceC)

impl<P, Item, F> DistributedSink<Item> for MaxBy<P, F> where
    F: for<'a, 'b> FnMut<(&'a <P as DistributedPipe<Item>>::Output, &'b <P as DistributedPipe<Item>>::Output), Output = Ordering> + Clone + ProcessSend + 'static,
    P: DistributedPipe<Item>,
    <P as DistributedPipe<Item>>::Output: ProcessSend,
    <P as DistributedPipe<Item>>::Output: 'static, 

type Done = <<MaxBy<P, F> as DistributedSink<Item>>::ReduceC as Reducer<<<MaxBy<P, F> as DistributedSink<Item>>::ReduceB as Reducer<<<MaxBy<P, F> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<<P as DistributedPipe<Item>>::Output, MaxBy<<P as DistributedPipe<Item>>::Output, F>>

type ReduceB = FolderSyncReducer<<<MaxBy<P, F> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done, MaxBy<<P as DistributedPipe<Item>>::Output, F>>

type ReduceC = FolderSyncReducer<<<MaxBy<P, F> as DistributedSink<Item>>::ReduceB as Reducer<<<MaxBy<P, F> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done, MaxBy<<P as DistributedPipe<Item>>::Output, F>>

fn reducers(
    self
) -> (P, <MaxBy<P, F> as DistributedSink<Item>>::ReduceA, <MaxBy<P, F> as DistributedSink<Item>>::ReduceB, <MaxBy<P, F> as DistributedSink<Item>>::ReduceC)

impl<P, Item, F> DistributedSink<Item> for MinBy<P, F> where
    F: for<'a, 'b> FnMut<(&'a <P as DistributedPipe<Item>>::Output, &'b <P as DistributedPipe<Item>>::Output), Output = Ordering> + Clone + ProcessSend + 'static,
    P: DistributedPipe<Item>,
    <P as DistributedPipe<Item>>::Output: ProcessSend,
    <P as DistributedPipe<Item>>::Output: 'static, 

type Done = <<MinBy<P, F> as DistributedSink<Item>>::ReduceC as Reducer<<<MinBy<P, F> as DistributedSink<Item>>::ReduceB as Reducer<<<MinBy<P, F> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<<P as DistributedPipe<Item>>::Output, MinBy<<P as DistributedPipe<Item>>::Output, F>>

type ReduceB = FolderSyncReducer<<<MinBy<P, F> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done, MinBy<<P as DistributedPipe<Item>>::Output, F>>

type ReduceC = FolderSyncReducer<<<MinBy<P, F> as DistributedSink<Item>>::ReduceB as Reducer<<<MinBy<P, F> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done, MinBy<<P as DistributedPipe<Item>>::Output, F>>

fn reducers(
    self
) -> (P, <MinBy<P, F> as DistributedSink<Item>>::ReduceA, <MinBy<P, F> as DistributedSink<Item>>::ReduceB, <MinBy<P, F> as DistributedSink<Item>>::ReduceC)

impl<P, Item, F, B> DistributedSink<Item> for MaxByKey<P, F> where
    B: Ord + 'static,
    F: for<'a> FnMut<(&'a <P as DistributedPipe<Item>>::Output,), Output = B> + Clone + ProcessSend + 'static,
    P: DistributedPipe<Item>,
    <P as DistributedPipe<Item>>::Output: ProcessSend,
    <P as DistributedPipe<Item>>::Output: 'static, 

type Done = <<MaxByKey<P, F> as DistributedSink<Item>>::ReduceC as Reducer<<<MaxByKey<P, F> as DistributedSink<Item>>::ReduceB as Reducer<<<MaxByKey<P, F> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<<P as DistributedPipe<Item>>::Output, MaxByKey<<P as DistributedPipe<Item>>::Output, F, B>>

type ReduceB = FolderSyncReducer<<<MaxByKey<P, F> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done, MaxByKey<<P as DistributedPipe<Item>>::Output, F, B>>

type ReduceC = FolderSyncReducer<<<MaxByKey<P, F> as DistributedSink<Item>>::ReduceB as Reducer<<<MaxByKey<P, F> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done, MaxByKey<<P as DistributedPipe<Item>>::Output, F, B>>

fn reducers(
    self
) -> (P, <MaxByKey<P, F> as DistributedSink<Item>>::ReduceA, <MaxByKey<P, F> as DistributedSink<Item>>::ReduceB, <MaxByKey<P, F> as DistributedSink<Item>>::ReduceC)

impl<P, Item, F, B> DistributedSink<Item> for MinByKey<P, F> where
    B: Ord + 'static,
    F: for<'a> FnMut<(&'a <P as DistributedPipe<Item>>::Output,), Output = B> + Clone + ProcessSend + 'static,
    P: DistributedPipe<Item>,
    <P as DistributedPipe<Item>>::Output: ProcessSend,
    <P as DistributedPipe<Item>>::Output: 'static, 

type Done = <<MinByKey<P, F> as DistributedSink<Item>>::ReduceC as Reducer<<<MinByKey<P, F> as DistributedSink<Item>>::ReduceB as Reducer<<<MinByKey<P, F> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<<P as DistributedPipe<Item>>::Output, MinByKey<<P as DistributedPipe<Item>>::Output, F, B>>

type ReduceB = FolderSyncReducer<<<MinByKey<P, F> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done, MinByKey<<P as DistributedPipe<Item>>::Output, F, B>>

type ReduceC = FolderSyncReducer<<<MinByKey<P, F> as DistributedSink<Item>>::ReduceB as Reducer<<<MinByKey<P, F> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done, MinByKey<<P as DistributedPipe<Item>>::Output, F, B>>

fn reducers(
    self
) -> (P, <MinByKey<P, F> as DistributedSink<Item>>::ReduceA, <MinByKey<P, F> as DistributedSink<Item>>::ReduceB, <MinByKey<P, F> as DistributedSink<Item>>::ReduceC)

impl<P, Item, ID, F, B> DistributedSink<Item> for Fold<P, ID, F, B> where
    B: ProcessSend + 'static,
    F: FnMut<(B, Either<<P as DistributedPipe<Item>>::Output, B>), Output = B> + Clone + ProcessSend + 'static,
    ID: FnMut<(), Output = B> + Clone + ProcessSend + 'static,
    P: DistributedPipe<Item>, 

type Done = <<Fold<P, ID, F, B> as DistributedSink<Item>>::ReduceC as Reducer<<<Fold<P, ID, F, B> as DistributedSink<Item>>::ReduceB as Reducer<<<Fold<P, ID, F, B> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done>>::Done

type Pipe = P

type ReduceA = FolderSyncReducer<<P as DistributedPipe<Item>>::Output, FoldFolder<<P as DistributedPipe<Item>>::Output, ID, F, B, StepA>>

type ReduceB = FolderSyncReducer<<<Fold<P, ID, F, B> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done, FoldFolder<<P as DistributedPipe<Item>>::Output, ID, F, B, StepB>>

type ReduceC = FolderSyncReducer<<<Fold<P, ID, F, B> as DistributedSink<Item>>::ReduceB as Reducer<<<Fold<P, ID, F, B> as DistributedSink<Item>>::ReduceA as Reducer<<P as DistributedPipe<Item>>::Output>>::Done>>::Done, FoldFolder<<P as DistributedPipe<Item>>::Output, ID, F, B, StepB>>

fn reducers(
    self
) -> (P, <Fold<P, ID, F, B> as DistributedSink<Item>>::ReduceA, <Fold<P, ID, F, B> as DistributedSink<Item>>::ReduceB, <Fold<P, ID, F, B> as DistributedSink<Item>>::ReduceC)

impl<P, Item, T> DistributedSink<Item> for Collect<P, T> where
    P: DistributedPipe<Item>,
    T: FromDistributedStream<<P as DistributedPipe<Item>>::Output>, 

type Done = T

type Pipe = P

type ReduceA = <T as FromDistributedStream<<P as DistributedPipe<Item>>::Output>>::ReduceA

type ReduceB = <T as FromDistributedStream<<P as DistributedPipe<Item>>::Output>>::ReduceB

type ReduceC = <T as FromDistributedStream<<P as DistributedPipe<Item>>::Output>>::ReduceC

fn reducers(
    self
) -> (<Collect<P, T> as DistributedSink<Item>>::Pipe, <Collect<P, T> as DistributedSink<Item>>::ReduceA, <Collect<P, T> as DistributedSink<Item>>::ReduceB, <Collect<P, T> as DistributedSink<Item>>::ReduceC)

Loading content...