Trait amadeus::dist_iter::Reducer

pub trait Reducer {
    type Item;
    type Output;
    fn push(&mut self, item: Self::Item) -> bool;
    fn ret(self) -> Self::Output;
}

Associated Types

type Item

type Output

Loading content...

Required methods

fn push(&mut self, item: Self::Item) -> bool

fn ret(self) -> Self::Output

Loading content...

Implementors

impl Reducer for BoolAndReducer

type Item = bool

type Output = bool

fn push(&mut self, item: <BoolAndReducer as Reducer>::Item) -> bool

fn ret(self) -> <BoolAndReducer as Reducer>::Output

impl Reducer for BoolOrReducer

type Item = bool

type Output = bool

fn push(&mut self, item: <BoolOrReducer as Reducer>::Item) -> bool

fn ret(self) -> <BoolOrReducer as Reducer>::Output

impl Reducer for ReduceA0

type Item = Sum0

type Output = ()

fn push(&mut self, item: <ReduceA0 as Reducer>::Item) -> bool

fn ret(self) -> <ReduceA0 as Reducer>::Output

impl Reducer for ReduceB0

type Item = ()

type Output = ()

fn push(&mut self, item: <ReduceB0 as Reducer>::Item) -> bool

fn ret(self) -> <ReduceB0 as Reducer>::Output

impl<A> Reducer for CountReducer<A>

type Item = A

type Output = usize

fn push(&mut self, _item: <CountReducer<A> as Reducer>::Item) -> bool

fn ret(self) -> <CountReducer<A> as Reducer>::Output

impl<A> Reducer for MostFrequentReducer<A> where
    A: Clone + Hash + Eq, 

type Item = A

type Output = Top<A, usize>

fn push(&mut self, item: <MostFrequentReducer<A> as Reducer>::Item) -> bool

fn ret(self) -> <MostFrequentReducer<A> as Reducer>::Output

impl<A> Reducer for ReduceA1<A> where
    A: Reducer, 

type Item = Sum1<<A as Reducer>::Item>

type Output = (<A as Reducer>::Output,)

fn push(&mut self, item: <ReduceA1<A> as Reducer>::Item) -> bool

fn ret(self) -> <ReduceA1<A> as Reducer>::Output

impl<A> Reducer for ReduceB1<A> where
    A: Reducer, 

type Item = (<A as Reducer>::Item,)

type Output = (<A as Reducer>::Output,)

fn push(&mut self, item: <ReduceB1<A> as Reducer>::Item) -> bool

fn ret(self) -> <ReduceB1<A> as Reducer>::Output

impl<A> Reducer for SampleUnstableReducer<A>

type Item = A

type Output = SampleUnstable<A>

fn push(&mut self, item: <SampleUnstableReducer<A> as Reducer>::Item) -> bool

fn ret(self) -> <SampleUnstableReducer<A> as Reducer>::Output

impl<A, B> Reducer for MostDistinctReducer<A, B> where
    A: Clone + Hash + Eq,
    B: Hash, 

type Item = (A, B)

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

fn push(&mut self, item: <MostDistinctReducer<A, B> as Reducer>::Item) -> bool

fn ret(self) -> <MostDistinctReducer<A, B> as Reducer>::Output

impl<A, B> Reducer for ReduceA2<A, B> where
    A: Reducer,
    B: Reducer, 

type Item = Sum2<<A as Reducer>::Item, <B as Reducer>::Item>

type Output = (<A as Reducer>::Output, <B as Reducer>::Output)

fn push(&mut self, item: <ReduceA2<A, B> as Reducer>::Item) -> bool

fn ret(self) -> <ReduceA2<A, B> as Reducer>::Output

impl<A, B> Reducer for ReduceB2<A, B> where
    A: Reducer,
    B: Reducer, 

type Item = (<A as Reducer>::Item, <B as Reducer>::Item)

type Output = (<A as Reducer>::Output, <B as Reducer>::Output)

fn push(&mut self, item: <ReduceB2<A, B> as Reducer>::Item) -> bool

fn ret(self) -> <ReduceB2<A, B> as Reducer>::Output

impl<A, B> Reducer for SumReducer<A, B> where
    B: Sum<A> + Sum<B>, 

type Item = A

type Output = B

fn push(&mut self, item: <SumReducer<A, B> as Reducer>::Item) -> bool

fn ret(self) -> <SumReducer<A, B> as Reducer>::Output

impl<A, B, C> Reducer for ReduceA3<A, B, C> where
    A: Reducer,
    B: Reducer,
    C: Reducer, 

type Item = Sum3<<A as Reducer>::Item, <B as Reducer>::Item, <C as Reducer>::Item>

type Output = (<A as Reducer>::Output, <B as Reducer>::Output, <C as Reducer>::Output)

fn push(&mut self, item: <ReduceA3<A, B, C> as Reducer>::Item) -> bool

fn ret(self) -> <ReduceA3<A, B, C> as Reducer>::Output

impl<A, B, C> Reducer for ReduceB3<A, B, C> where
    A: Reducer,
    B: Reducer,
    C: Reducer, 

type Item = (<A as Reducer>::Item, <B as Reducer>::Item, <C as Reducer>::Item)

type Output = (<A as Reducer>::Output, <B as Reducer>::Output, <C as Reducer>::Output)

fn push(&mut self, item: <ReduceB3<A, B, C> as Reducer>::Item) -> bool

fn ret(self) -> <ReduceB3<A, B, C> as Reducer>::Output

impl<A, B, C, D> Reducer for ReduceA4<A, B, C, D> where
    A: Reducer,
    B: Reducer,
    C: Reducer,
    D: Reducer, 

type Item = Sum4<<A as Reducer>::Item, <B as Reducer>::Item, <C as Reducer>::Item, <D as Reducer>::Item>

type Output = (<A as Reducer>::Output, <B as Reducer>::Output, <C as Reducer>::Output, <D as Reducer>::Output)

fn push(&mut self, item: <ReduceA4<A, B, C, D> as Reducer>::Item) -> bool

fn ret(self) -> <ReduceA4<A, B, C, D> as Reducer>::Output

impl<A, B, C, D> Reducer for ReduceB4<A, B, C, D> where
    A: Reducer,
    B: Reducer,
    C: Reducer,
    D: Reducer, 

type Item = (<A as Reducer>::Item, <B as Reducer>::Item, <C as Reducer>::Item, <D as Reducer>::Item)

type Output = (<A as Reducer>::Output, <B as Reducer>::Output, <C as Reducer>::Output, <D as Reducer>::Output)

fn push(&mut self, item: <ReduceB4<A, B, C, D> as Reducer>::Item) -> bool

fn ret(self) -> <ReduceB4<A, B, C, D> as Reducer>::Output

impl<A, B, C, D, E> Reducer for ReduceA5<A, B, C, D, E> where
    A: Reducer,
    B: Reducer,
    C: Reducer,
    D: Reducer,
    E: Reducer, 

type Item = Sum5<<A as Reducer>::Item, <B as Reducer>::Item, <C as Reducer>::Item, <D as Reducer>::Item, <E as Reducer>::Item>

type Output = (<A as Reducer>::Output, <B as Reducer>::Output, <C as Reducer>::Output, <D as Reducer>::Output, <E as Reducer>::Output)

fn push(&mut self, item: <ReduceA5<A, B, C, D, E> as Reducer>::Item) -> bool

fn ret(self) -> <ReduceA5<A, B, C, D, E> as Reducer>::Output

impl<A, B, C, D, E> Reducer for ReduceB5<A, B, C, D, E> where
    A: Reducer,
    B: Reducer,
    C: Reducer,
    D: Reducer,
    E: Reducer, 

type Item = (<A as Reducer>::Item, <B as Reducer>::Item, <C as Reducer>::Item, <D as Reducer>::Item, <E as Reducer>::Item)

type Output = (<A as Reducer>::Output, <B as Reducer>::Output, <C as Reducer>::Output, <D as Reducer>::Output, <E as Reducer>::Output)

fn push(&mut self, item: <ReduceB5<A, B, C, D, E> as Reducer>::Item) -> bool

fn ret(self) -> <ReduceB5<A, B, C, D, E> as Reducer>::Output

impl<A, B, C, D, E, F> Reducer for ReduceA6<A, B, C, D, E, F> where
    A: Reducer,
    B: Reducer,
    C: Reducer,
    D: Reducer,
    E: Reducer,
    F: Reducer, 

type Item = Sum6<<A as Reducer>::Item, <B as Reducer>::Item, <C as Reducer>::Item, <D as Reducer>::Item, <E as Reducer>::Item, <F as Reducer>::Item>

type Output = (<A as Reducer>::Output, <B as Reducer>::Output, <C as Reducer>::Output, <D as Reducer>::Output, <E as Reducer>::Output, <F as Reducer>::Output)

fn push(&mut self, item: <ReduceA6<A, B, C, D, E, F> as Reducer>::Item) -> bool

fn ret(self) -> <ReduceA6<A, B, C, D, E, F> as Reducer>::Output

impl<A, B, C, D, E, F> Reducer for ReduceB6<A, B, C, D, E, F> where
    A: Reducer,
    B: Reducer,
    C: Reducer,
    D: Reducer,
    E: Reducer,
    F: Reducer, 

type Item = (<A as Reducer>::Item, <B as Reducer>::Item, <C as Reducer>::Item, <D as Reducer>::Item, <E as Reducer>::Item, <F as Reducer>::Item)

type Output = (<A as Reducer>::Output, <B as Reducer>::Output, <C as Reducer>::Output, <D as Reducer>::Output, <E as Reducer>::Output, <F as Reducer>::Output)

fn push(&mut self, item: <ReduceB6<A, B, C, D, E, F> as Reducer>::Item) -> bool

fn ret(self) -> <ReduceB6<A, B, C, D, E, F> as Reducer>::Output

impl<A, B, C, D, E, F, G> Reducer for ReduceA7<A, B, C, D, E, F, G> where
    A: Reducer,
    B: Reducer,
    C: Reducer,
    D: Reducer,
    E: Reducer,
    F: Reducer,
    G: Reducer, 

type Item = Sum7<<A as Reducer>::Item, <B as Reducer>::Item, <C as Reducer>::Item, <D as Reducer>::Item, <E as Reducer>::Item, <F as Reducer>::Item, <G as Reducer>::Item>

type Output = (<A as Reducer>::Output, <B as Reducer>::Output, <C as Reducer>::Output, <D as Reducer>::Output, <E as Reducer>::Output, <F as Reducer>::Output, <G as Reducer>::Output)

fn push(
    &mut self,
    item: <ReduceA7<A, B, C, D, E, F, G> as Reducer>::Item
) -> bool

fn ret(self) -> <ReduceA7<A, B, C, D, E, F, G> as Reducer>::Output

impl<A, B, C, D, E, F, G> Reducer for ReduceB7<A, B, C, D, E, F, G> where
    A: Reducer,
    B: Reducer,
    C: Reducer,
    D: Reducer,
    E: Reducer,
    F: Reducer,
    G: Reducer, 

type Item = (<A as Reducer>::Item, <B as Reducer>::Item, <C as Reducer>::Item, <D as Reducer>::Item, <E as Reducer>::Item, <F as Reducer>::Item, <G as Reducer>::Item)

type Output = (<A as Reducer>::Output, <B as Reducer>::Output, <C as Reducer>::Output, <D as Reducer>::Output, <E as Reducer>::Output, <F as Reducer>::Output, <G as Reducer>::Output)

fn push(
    &mut self,
    item: <ReduceB7<A, B, C, D, E, F, G> as Reducer>::Item
) -> bool

fn ret(self) -> <ReduceB7<A, B, C, D, E, F, G> as Reducer>::Output

impl<A, B, C, D, E, F, G, H> Reducer for ReduceA8<A, B, C, D, E, F, G, H> where
    A: Reducer,
    B: Reducer,
    C: Reducer,
    D: Reducer,
    E: Reducer,
    F: Reducer,
    G: Reducer,
    H: Reducer, 

type Item = Sum8<<A as Reducer>::Item, <B as Reducer>::Item, <C as Reducer>::Item, <D as Reducer>::Item, <E as Reducer>::Item, <F as Reducer>::Item, <G as Reducer>::Item, <H as Reducer>::Item>

type Output = (<A as Reducer>::Output, <B as Reducer>::Output, <C as Reducer>::Output, <D as Reducer>::Output, <E as Reducer>::Output, <F as Reducer>::Output, <G as Reducer>::Output, <H as Reducer>::Output)

fn push(
    &mut self,
    item: <ReduceA8<A, B, C, D, E, F, G, H> as Reducer>::Item
) -> bool

fn ret(self) -> <ReduceA8<A, B, C, D, E, F, G, H> as Reducer>::Output

impl<A, B, C, D, E, F, G, H> Reducer for ReduceB8<A, B, C, D, E, F, G, H> where
    A: Reducer,
    B: Reducer,
    C: Reducer,
    D: Reducer,
    E: Reducer,
    F: Reducer,
    G: Reducer,
    H: Reducer, 

type Item = (<A as Reducer>::Item, <B as Reducer>::Item, <C as Reducer>::Item, <D as Reducer>::Item, <E as Reducer>::Item, <F as Reducer>::Item, <G as Reducer>::Item, <H as Reducer>::Item)

type Output = (<A as Reducer>::Output, <B as Reducer>::Output, <C as Reducer>::Output, <D as Reducer>::Output, <E as Reducer>::Output, <F as Reducer>::Output, <G as Reducer>::Output, <H as Reducer>::Output)

fn push(
    &mut self,
    item: <ReduceB8<A, B, C, D, E, F, G, H> as Reducer>::Item
) -> bool

fn ret(self) -> <ReduceB8<A, B, C, D, E, F, G, H> as Reducer>::Output

impl<A, B, F> Reducer for CombineReducer<A, B, F> where
    F: Combiner<B>,
    Option<B>: From<A>, 

type Item = A

type Output = Option<B>

fn push(&mut self, item: <CombineReducer<A, B, F> as Reducer>::Item) -> bool

fn ret(self) -> <CombineReducer<A, B, F> as Reducer>::Output

impl<A, F> Reducer for AllReducer<A, F> where
    F: FnMut(A) -> bool, 

type Item = A

type Output = bool

fn push(&mut self, item: <AllReducer<A, F> as Reducer>::Item) -> bool

fn ret(self) -> <AllReducer<A, F> as Reducer>::Output

impl<A, F> Reducer for AnyReducer<A, F> where
    F: FnMut(A) -> bool, 

type Item = A

type Output = bool

fn push(&mut self, item: <AnyReducer<A, F> as Reducer>::Item) -> bool

fn ret(self) -> <AnyReducer<A, F> as Reducer>::Output

impl<A, F> Reducer for ForEachReducer<A, F> where
    F: FnMut(A) + Clone, 

type Item = A

type Output = ()

fn push(&mut self, item: <ForEachReducer<A, F> as Reducer>::Item) -> bool

fn ret(self) -> <ForEachReducer<A, F> as Reducer>::Output

impl<A, ID, F, B> Reducer for FoldReducerA<A, ID, F, B> where
    F: FnMut(B, Either<A, B>) -> B + Clone,
    ID: FnMut() -> B + Clone, 

type Item = A

type Output = B

fn push(&mut self, item: <FoldReducerA<A, ID, F, B> as Reducer>::Item) -> bool

fn ret(self) -> <FoldReducerA<A, ID, F, B> as Reducer>::Output

impl<A, ID, F, B> Reducer for FoldReducerB<A, ID, F, B> where
    F: FnMut(B, Either<A, B>) -> B + Clone,
    ID: FnMut() -> B + Clone, 

type Item = B

type Output = B

fn push(&mut self, item: <FoldReducerB<A, ID, F, B> as Reducer>::Item) -> bool

fn ret(self) -> <FoldReducerB<A, ID, F, B> as Reducer>::Output

impl<A, T> Reducer for PushReducer<A, T> where
    T: Push<A>, 

type Item = A

type Output = T

fn push(&mut self, item: <PushReducer<A, T> as Reducer>::Item) -> bool

fn ret(self) -> <PushReducer<A, T> as Reducer>::Output

impl<A, T, B> Reducer for ExtendReducer<A, T> where
    A: IntoIterator<Item = B>,
    T: Extend<B>, 

type Item = A

type Output = T

fn push(&mut self, item: <ExtendReducer<A, T> as Reducer>::Item) -> bool

fn ret(self) -> <ExtendReducer<A, T> as Reducer>::Output

impl<R> Reducer for OptionReducer<R> where
    R: Reducer, 

type Item = Option<<R as Reducer>::Item>

type Output = Option<<R as Reducer>::Output>

fn push(&mut self, item: <OptionReducer<R> as Reducer>::Item) -> bool

fn ret(self) -> <OptionReducer<R> as Reducer>::Output

impl<R, B> Reducer for NonzeroReducer<R> where
    R: Reducer<Output = Zeroable<B>>, 

type Item = <R as Reducer>::Item

type Output = B

fn push(&mut self, item: <NonzeroReducer<R> as Reducer>::Item) -> bool

fn ret(self) -> <NonzeroReducer<R> as Reducer>::Output

impl<R, E> Reducer for ResultReducer<R, E> where
    R: Reducer, 

type Item = Result<<R as Reducer>::Item, E>

type Output = Result<<R as Reducer>::Output, E>

fn push(&mut self, item: <ResultReducer<R, E> as Reducer>::Item) -> bool

fn ret(self) -> <ResultReducer<R, E> as Reducer>::Output

impl<R, T> Reducer for IntoReducer<R, T> where
    R: Reducer,
    <R as Reducer>::Output: Into<T>, 

type Item = <R as Reducer>::Item

type Output = T

fn push(&mut self, item: <IntoReducer<R, T> as Reducer>::Item) -> bool

fn ret(self) -> <IntoReducer<R, T> as Reducer>::Output

Loading content...