Trait amadeus::par_sink::FolderSync

pub trait FolderSync<Item> {
    type State;
    type Done;
    fn zero(&mut self) -> Self::State;
    fn push(&mut self, state: &mut Self::State, item: Item);
    fn done(&mut self, state: Self::State) -> Self::Done;
}

Associated Types

type State

type Done

Loading content...

Required methods

fn zero(&mut self) -> Self::State

fn push(&mut self, state: &mut Self::State, item: Item)

fn done(&mut self, state: Self::State) -> Self::Done

Loading content...

Implementors

impl FolderSync<f64> for MeanFolder<StepA>

type State = State

type Done = f64

fn zero(&mut self) -> <MeanFolder<StepA> as FolderSync<f64>>::State

fn push(
    &mut self,
    state: &mut <MeanFolder<StepA> as FolderSync<f64>>::State,
    item: f64
)

fn done(
    &mut self,
    state: <MeanFolder<StepA> as FolderSync<f64>>::State
) -> <MeanFolder<StepA> as FolderSync<f64>>::Done

impl FolderSync<f64> for SDFolder<StepA>

type State = SDState

type Done = f64

fn zero(&mut self) -> <SDFolder<StepA> as FolderSync<f64>>::State

fn push(
    &mut self,
    state: &mut <SDFolder<StepA> as FolderSync<f64>>::State,
    item: f64
)

fn done(
    &mut self,
    state: <SDFolder<StepA> as FolderSync<f64>>::State
) -> <SDFolder<StepA> as FolderSync<f64>>::Done

impl FolderSync<SDState> for SDFolder<StepB>

type State = SDState

type Done = f64

fn zero(&mut self) -> <SDFolder<StepB> as FolderSync<SDState>>::State

fn push(
    &mut self,
    state: &mut <SDFolder<StepB> as FolderSync<SDState>>::State,
    item: SDState
)

fn done(
    &mut self,
    state: <SDFolder<StepB> as FolderSync<SDState>>::State
) -> <SDFolder<StepB> as FolderSync<SDState>>::Done

impl FolderSync<State> for MeanFolder<StepB>

type State = State

type Done = f64

fn zero(&mut self) -> <MeanFolder<StepB> as FolderSync<State>>::State

fn push(
    &mut self,
    state: &mut <MeanFolder<StepB> as FolderSync<State>>::State,
    item: State
)

fn done(
    &mut self,
    state: <MeanFolder<StepB> as FolderSync<State>>::State
) -> <MeanFolder<StepB> as FolderSync<State>>::Done

impl<A, B> FolderSync<(A, B)> for MostDistinctFolder where
    A: Clone + Hash + Eq + Send + 'static,
    B: Hash + 'static, 

type State = Top<A, HyperLogLogMagnitude<B>>

type Done = <MostDistinctFolder as FolderSync<(A, B)>>::State

fn zero(&mut self) -> <MostDistinctFolder as FolderSync<(A, B)>>::State

fn push(
    &mut self,
    state: &mut <MostDistinctFolder as FolderSync<(A, B)>>::State,
    item: (A, B)
)

fn done(
    &mut self,
    state: <MostDistinctFolder as FolderSync<(A, B)>>::State
) -> <MostDistinctFolder as FolderSync<(A, B)>>::Done

impl<A, ID, F, Item> FolderSync<Item> for FoldFolder<A, ID, F, Item, StepB> where
    F: FnMut<(Item, Either<A, Item>), Output = Item>,
    ID: FnMut<(), Output = Item>, 

type State = Item

type Done = <FoldFolder<A, ID, F, Item, StepB> as FolderSync<Item>>::State

fn zero(
    &mut self
) -> <FoldFolder<A, ID, F, Item, StepB> as FolderSync<Item>>::State

fn push(
    &mut self,
    state: &mut <FoldFolder<A, ID, F, Item, StepB> as FolderSync<Item>>::State,
    item: Item
)

fn done(
    &mut self,
    state: <FoldFolder<A, ID, F, Item, StepB> as FolderSync<Item>>::State
) -> <FoldFolder<A, ID, F, Item, StepB> as FolderSync<Item>>::Done

impl<B> FolderSync<Vec<(B, usize)>> for HistogramFolder<B, StepB> where
    B: Hash + Ord, 

type State = Vec<(B, usize)>

type Done = <HistogramFolder<B, StepB> as FolderSync<Vec<(B, usize)>>>::State

fn zero(
    &mut self
) -> <HistogramFolder<B, StepB> as FolderSync<Vec<(B, usize)>>>::State

fn push(
    &mut self,
    state: &mut <HistogramFolder<B, StepB> as FolderSync<Vec<(B, usize)>>>::State,
    b: Vec<(B, usize)>
)

fn done(
    &mut self,
    state: <HistogramFolder<B, StepB> as FolderSync<Vec<(B, usize)>>>::State
) -> <HistogramFolder<B, StepB> as FolderSync<Vec<(B, usize)>>>::Done

impl<B> FolderSync<HashMap<B, usize, RandomState>> for HistogramFolder<B, StepB> where
    B: Hash + Ord, 

type State = Vec<(B, usize)>

type Done = <HistogramFolder<B, StepB> as FolderSync<HashMap<B, usize, RandomState>>>::State

fn zero(
    &mut self
) -> <HistogramFolder<B, StepB> as FolderSync<HashMap<B, usize, RandomState>>>::State

fn push(
    &mut self,
    state: &mut <HistogramFolder<B, StepB> as FolderSync<HashMap<B, usize, RandomState>>>::State,
    b: HashMap<B, usize, RandomState>
)

fn done(
    &mut self,
    state: <HistogramFolder<B, StepB> as FolderSync<HashMap<B, usize, RandomState>>>::State
) -> <HistogramFolder<B, StepB> as FolderSync<HashMap<B, usize, RandomState>>>::Done

impl<C, Item, B> FolderSync<Item> for C where
    C: CombinerSync<Done = B>,
    Item: Into<Option<B>>, 

type State = Option<B>

type Done = <C as FolderSync<Item>>::State

fn zero(&mut self) -> <C as FolderSync<Item>>::State

fn push(&mut self, state: &mut <C as FolderSync<Item>>::State, item: Item)

fn done(
    &mut self,
    state: <C as FolderSync<Item>>::State
) -> <C as FolderSync<Item>>::Done

impl<F, A, Item> FolderSync<Item> for ReduceFn<F, A> where
    F: FnMut<(A, A), Output = A>,
    Item: Into<Option<A>>, 

type State = Option<A>

type Done = <ReduceFn<F, A> as FolderSync<Item>>::State

fn zero(&mut self) -> <ReduceFn<F, A> as FolderSync<Item>>::State

fn push(
    &mut self,
    state: &mut <ReduceFn<F, A> as FolderSync<Item>>::State,
    item: Item
)

fn done(
    &mut self,
    state: <ReduceFn<F, A> as FolderSync<Item>>::State
) -> <ReduceFn<F, A> as FolderSync<Item>>::Done

impl<Item> FolderSync<Item> for CountFolder

type State = usize

type Done = <CountFolder as FolderSync<Item>>::State

fn zero(&mut self) -> <CountFolder as FolderSync<Item>>::State

fn push(
    &mut self,
    state: &mut <CountFolder as FolderSync<Item>>::State,
    _item: Item
)

fn done(
    &mut self,
    state: <CountFolder as FolderSync<Item>>::State
) -> <CountFolder as FolderSync<Item>>::Done

impl<Item> FolderSync<Item> for HistogramFolder<Item, StepA> where
    Item: Hash + Ord, 

type State = HashMap<Item, usize, RandomState>

type Done = <HistogramFolder<Item, StepA> as FolderSync<Item>>::State

fn zero(&mut self) -> <HistogramFolder<Item, StepA> as FolderSync<Item>>::State

fn push(
    &mut self,
    state: &mut <HistogramFolder<Item, StepA> as FolderSync<Item>>::Done,
    item: Item
)

fn done(
    &mut self,
    state: <HistogramFolder<Item, StepA> as FolderSync<Item>>::State
) -> <HistogramFolder<Item, StepA> as FolderSync<Item>>::Done

impl<Item> FolderSync<Item> for MostFrequentFolder where
    Item: Clone + Hash + Eq + Send + 'static, 

type State = Top<Item, usize>

type Done = <MostFrequentFolder as FolderSync<Item>>::State

fn zero(&mut self) -> <MostFrequentFolder as FolderSync<Item>>::State

fn push(
    &mut self,
    state: &mut <MostFrequentFolder as FolderSync<Item>>::State,
    item: Item
)

fn done(
    &mut self,
    state: <MostFrequentFolder as FolderSync<Item>>::State
) -> <MostFrequentFolder as FolderSync<Item>>::Done

impl<Item> FolderSync<Item> for SampleUnstableFolder

type State = SampleUnstable<Item>

type Done = <SampleUnstableFolder as FolderSync<Item>>::State

fn zero(&mut self) -> <SampleUnstableFolder as FolderSync<Item>>::State

fn push(
    &mut self,
    state: &mut <SampleUnstableFolder as FolderSync<Item>>::State,
    item: Item
)

fn done(
    &mut self,
    state: <SampleUnstableFolder as FolderSync<Item>>::State
) -> <SampleUnstableFolder as FolderSync<Item>>::Done

impl<Item> FolderSync<Item> for SumZeroFolder<Item> where
    Option<Item>: Sum<Item>, 

type State = Item

type Done = <SumZeroFolder<Item> as FolderSync<Item>>::State

fn zero(&mut self) -> <SumZeroFolder<Item> as FolderSync<Item>>::Done

fn push(
    &mut self,
    state: &mut <SumZeroFolder<Item> as FolderSync<Item>>::Done,
    item: Item
)

fn done(
    &mut self,
    state: <SumZeroFolder<Item> as FolderSync<Item>>::State
) -> <SumZeroFolder<Item> as FolderSync<Item>>::Done

impl<Item, B> FolderSync<Item> for SumFolder<B> where
    B: Sum<Item> + Sum<B>, 

type State = B

type Done = <SumFolder<B> as FolderSync<Item>>::State

fn zero(&mut self) -> <SumFolder<B> as FolderSync<Item>>::Done

fn push(
    &mut self,
    state: &mut <SumFolder<B> as FolderSync<Item>>::Done,
    item: Item
)

fn done(
    &mut self,
    state: <SumFolder<B> as FolderSync<Item>>::State
) -> <SumFolder<B> as FolderSync<Item>>::Done

impl<Item, F> FolderSync<Item> for SortFolder<F> where
    F: Fn<(&Item, &Item), Output = Ordering> + Clone, 

type State = Sort<Item, F>

type Done = <SortFolder<F> as FolderSync<Item>>::State

fn zero(&mut self) -> <SortFolder<F> as FolderSync<Item>>::Done

fn push(
    &mut self,
    state: &mut <SortFolder<F> as FolderSync<Item>>::Done,
    item: Item
)

fn done(
    &mut self,
    state: <SortFolder<F> as FolderSync<Item>>::State
) -> <SortFolder<F> as FolderSync<Item>>::Done

impl<Item, ID, F, B> FolderSync<Item> for FoldFolder<Item, ID, F, B, StepA> where
    F: FnMut<(B, Either<Item, B>), Output = B>,
    ID: FnMut<(), Output = B>, 

type State = B

type Done = <FoldFolder<Item, ID, F, B, StepA> as FolderSync<Item>>::State

fn zero(
    &mut self
) -> <FoldFolder<Item, ID, F, B, StepA> as FolderSync<Item>>::State

fn push(
    &mut self,
    state: &mut <FoldFolder<Item, ID, F, B, StepA> as FolderSync<Item>>::State,
    item: Item
)

fn done(
    &mut self,
    state: <FoldFolder<Item, ID, F, B, StepA> as FolderSync<Item>>::State
) -> <FoldFolder<Item, ID, F, B, StepA> as FolderSync<Item>>::Done

Loading content...