[−][src]Trait amadeus::par_sink::FolderSync
Associated Types
type Output
Required methods
Loading content...Implementors
impl<A> FolderSync<A> for CountFolder
[src]
type Output = usize
fn zero(&mut self) -> <CountFolder as FolderSync<A>>::Output
[src]
fn push(&mut self, state: &mut <CountFolder as FolderSync<A>>::Output, _item: A)
[src]
impl<A> FolderSync<A> for MostFrequentFolder where
A: Clone + Hash + Eq + Send + 'static,
[src]
A: Clone + Hash + Eq + Send + 'static,
type Output = Top<A, usize>
fn zero(&mut self) -> <MostFrequentFolder as FolderSync<A>>::Output
[src]
fn push(
&mut self,
state: &mut <MostFrequentFolder as FolderSync<A>>::Output,
item: A
)
[src]
&mut self,
state: &mut <MostFrequentFolder as FolderSync<A>>::Output,
item: A
)
impl<A> FolderSync<A> for SampleUnstableFolder
[src]
type Output = SampleUnstable<A>
fn zero(&mut self) -> <SampleUnstableFolder as FolderSync<A>>::Output
[src]
fn push(
&mut self,
state: &mut <SampleUnstableFolder as FolderSync<A>>::Output,
item: A
)
[src]
&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,
[src]
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
[src]
fn push(
&mut self,
state: &mut <MostDistinctFolder as FolderSync<(A, B)>>::Output,
item: (A, B)
)
[src]
&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>,
[src]
B: Sum<A> + Sum<B>,
type Output = B
fn zero(&mut self) -> <SumFolder<B> as FolderSync<A>>::Output
[src]
fn push(&mut self, state: &mut <SumFolder<B> as FolderSync<A>>::Output, item: A)
[src]
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,
[src]
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
[src]
&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)
)
[src]
&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,
[src]
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
[src]
&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>
)
[src]
&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,
[src]
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
[src]
fn push(
&mut self,
state: &mut <FoldFolder<A, ID, F, B, StepA> as FolderSync<A>>::Output,
item: A
)
[src]
&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,
[src]
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
[src]
fn push(
&mut self,
state: &mut <FoldFolder<A, ID, F, B, StepB> as FolderSync<B>>::Output,
item: B
)
[src]
&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,
[src]
B: Hash + Ord,
type Output = Vec<(B, usize)>
fn zero(
&mut self
) -> <HistogramFolder<B, StepB> as FolderSync<Vec<(B, usize)>>>::Output
[src]
&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)>
)
[src]
&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,
[src]
B: Hash + Ord,
type Output = Vec<(B, usize)>
fn zero(
&mut self
) -> <HistogramFolder<B, StepB> as FolderSync<HashMap<B, usize, RandomState>>>::Output
[src]
&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>
)
[src]
&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,
[src]
B: Hash + Ord,
type Output = HashMap<B, usize, RandomState>
fn zero(&mut self) -> <HistogramFolder<B, StepA> as FolderSync<B>>::Output
[src]
fn push(
&mut self,
state: &mut <HistogramFolder<B, StepA> as FolderSync<B>>::Output,
item: B
)
[src]
&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>,
[src]
Option<B>: Sum<B>,
type Output = B
fn zero(&mut self) -> <SumZeroFolder<B> as FolderSync<B>>::Output
[src]
fn push(
&mut self,
state: &mut <SumZeroFolder<B> as FolderSync<B>>::Output,
item: B
)
[src]
&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>,
[src]
A: Into<Option<B>>,
C: CombinerSync<Output = B>,
type Output = Option<B>
fn zero(&mut self) -> <C as FolderSync<A>>::Output
[src]
fn push(&mut self, state: &mut <C as FolderSync<A>>::Output, item: A)
[src]
impl<F, A, T> FolderSync<T> for ReduceFn<F, A> where
F: FnMut(A, A) -> A,
T: Into<Option<A>>,
[src]
F: FnMut(A, A) -> A,
T: Into<Option<A>>,