Trait differential_dataflow::operators::reduce::ReduceCore

pub trait ReduceCore<G: Scope, K: ToOwned + ?Sized, V: Data, R: Semigroup>
where
    G::Timestamp: Lattice + Ord,
{
    // Required method
    fn reduce_core<L, T2>(
        &self,
        name: &str,
        logic: L,
    ) -> Arranged<G, TraceAgent<T2>>
       where T2: for<'a> Trace<Key<'a> = &'a K, Time = G::Timestamp> + 'static,
             for<'a> T2::Val<'a>: IntoOwned<'a, Owned = V>,
             T2::Batch: Batch,
             T2::Builder: Builder<Input = Vec<((K::Owned, V), T2::Time, T2::Diff)>>,
             L: FnMut(&K, &[(&V, R)], &mut Vec<(V, T2::Diff)>, &mut Vec<(V, T2::Diff)>) + 'static;

    // Provided method
    fn reduce_abelian<L, T2>(
        &self,
        name: &str,
        logic: L,
    ) -> Arranged<G, TraceAgent<T2>>
       where T2: for<'a> Trace<Key<'a> = &'a K, Time = G::Timestamp> + 'static,
             for<'a> T2::Val<'a>: IntoOwned<'a, Owned = V>,
             T2::Diff: Abelian,
             T2::Batch: Batch,
             T2::Builder: Builder<Input = Vec<((K::Owned, V), T2::Time, T2::Diff)>>,
             L: FnMut(&K, &[(&V, R)], &mut Vec<(V, T2::Diff)>) + 'static { ... }
}

Extension trait for the reduce_core differential dataflow method.

Required Methods

fn reduce_core<L, T2>( &self, name: &str, logic: L, ) -> Arranged<G, TraceAgent<T2>>

where T2: for<'a> Trace<Key<'a> = &'a K, Time = G::Timestamp> + 'static, for<'a> T2::Val<'a>: IntoOwned<'a, Owned = V>, T2::Batch: Batch, T2::Builder: Builder<Input = Vec<((K::Owned, V), T2::Time, T2::Diff)>>, L: FnMut(&K, &[(&V, R)], &mut Vec<(V, T2::Diff)>, &mut Vec<(V, T2::Diff)>) + 'static,

Solves for output updates when presented with inputs and would-be outputs.

Unlike reduce_arranged, this method may be called with an empty input, and it may not be safe to index into the first element. At least one of the two collections will be non-empty.

Provided Methods

fn reduce_abelian<L, T2>( &self, name: &str, logic: L, ) -> Arranged<G, TraceAgent<T2>>

where T2: for<'a> Trace<Key<'a> = &'a K, Time = G::Timestamp> + 'static, for<'a> T2::Val<'a>: IntoOwned<'a, Owned = V>, T2::Diff: Abelian, T2::Batch: Batch, T2::Builder: Builder<Input = Vec<((K::Owned, V), T2::Time, T2::Diff)>>, L: FnMut(&K, &[(&V, R)], &mut Vec<(V, T2::Diff)>) + 'static,

Applies reduce to arranged data, and returns an arrangement of output data.

This method is used by the more ergonomic reduce, distinct, and count methods, although it can be very useful if one needs to manually attach and re-use existing arranged collections.

Examples

use differential_dataflow::input::Input;
use differential_dataflow::operators::reduce::ReduceCore;
use differential_dataflow::trace::Trace;
use differential_dataflow::trace::implementations::ValSpine;

::timely::example(|scope| {

    let trace =
    scope.new_collection_from(1 .. 10u32).1
         .map(|x| (x, x))
         .reduce_abelian::<_,ValSpine<_,_,_,_>>(
            "Example",
             move |_key, src, dst| dst.push((*src[0].0, 1))
         )
         .trace;
});

Object Safety

This trait is not object safe.

Implementors

impl<G, K, V, R> ReduceCore<G, K, V, R> for Collection<G, (K, V), R>

where G: Scope, G::Timestamp: Lattice + Ord, K: ExchangeData + Hashable, V: ExchangeData, R: ExchangeData + Semigroup,