Trait amadeus::par_sink::FolderSync

pub trait FolderSync<A> {
    type Output;
    fn zero(&mut self) -> Self::Output;
    fn push(&mut self, state: &mut Self::Output, item: A);
}

Associated Types

type Output

Loading content...

Required methods

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

fn push(&mut self, state: &mut Self::Output, item: A)

Loading content...

Implementors

impl<A> FolderSync<A> for CountFolder

type Output = usize

fn zero(&mut self) -> <CountFolder as FolderSync<A>>::Output

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

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

type Output = Top<A, usize>

fn zero(&mut self) -> <MostFrequentFolder as FolderSync<A>>::Output

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

impl<A> FolderSync<A> for SampleUnstableFolder

type Output = SampleUnstable<A>

fn zero(&mut self) -> <SampleUnstableFolder as FolderSync<A>>::Output

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

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

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

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

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

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

type Output = B

fn zero(&mut self) -> <SumFolder<B> as FolderSync<A>>::Output

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

impl<A, B, ID, F, C> FolderSync<(A, B)> for GroupByFolder<A, B, ID, F, C, StepA> where
    A: Eq + Hash,
    F: FnMut(C, Either<B, C>) -> C,
    ID: FnMut() -> C, 

type Output = HashMap<A, C, RandomState>

fn zero(
    &mut self
) -> <GroupByFolder<A, B, ID, F, C, StepA> as FolderSync<(A, B)>>::Output

fn push(
    &mut self,
    state: &mut <GroupByFolder<A, B, ID, F, C, StepA> as FolderSync<(A, B)>>::Output,
    (A, B)
)

impl<A, B, ID, F, C> FolderSync<HashMap<A, C, RandomState>> for GroupByFolder<A, B, ID, F, C, StepB> where
    A: Eq + Hash,
    F: FnMut(C, Either<B, C>) -> C,
    ID: FnMut() -> C, 

type Output = HashMap<A, C, RandomState>

fn zero(
    &mut self
) -> <GroupByFolder<A, B, ID, F, C, StepB> as FolderSync<HashMap<A, C, RandomState>>>::Output

fn push(
    &mut self,
    state: &mut <GroupByFolder<A, B, ID, F, C, StepB> as FolderSync<HashMap<A, C, RandomState>>>::Output,
    b: HashMap<A, C, RandomState>
)

impl<A, ID, F, B> FolderSync<A> for FoldFolder<A, ID, F, B, StepA> where
    F: FnMut(B, Either<A, B>) -> B,
    ID: FnMut() -> B, 

type Output = B

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

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

impl<A, ID, F, B> FolderSync<B> for FoldFolder<A, ID, F, B, StepB> where
    F: FnMut(B, Either<A, B>) -> B,
    ID: FnMut() -> B, 

type Output = B

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

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

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

type Output = Vec<(B, usize)>

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

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

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

type Output = Vec<(B, usize)>

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

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

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

type Output = HashMap<B, usize, RandomState>

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

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

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

type Output = B

fn zero(&mut self) -> <SumZeroFolder<B> as FolderSync<B>>::Output

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

impl<C, A, B> FolderSync<A> for C where
    A: Into<Option<B>>,
    C: CombinerSync<Output = B>, 

type Output = Option<B>

fn zero(&mut self) -> <C as FolderSync<A>>::Output

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

impl<F, A, T> FolderSync<T> for ReduceFn<F, A> where
    F: FnMut(A, A) -> A,
    T: Into<Option<A>>, 

type Output = Option<A>

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

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

Loading content...