Trait CountTotal

pub trait CountTotal<G: Scope, K: ExchangeData, R: Semigroup>
where
    G::Timestamp: TotalOrder + Lattice + Ord,
{
    // Required method
    fn count_total_core<R2: Semigroup + From<i8> + 'static>(
        &self,
    ) -> Collection<G, (K, R), R2>;

    // Provided method
    fn count_total(&self) -> Collection<G, (K, R), isize> { ... }
}

Extension trait for the count differential dataflow method.

Required Methods

fn count_total_core<R2: Semigroup + From<i8> + 'static>( &self, ) -> Collection<G, (K, R), R2>

Count for general integer differences.

This method allows count_total to produce collections whose difference type is something other than an isize integer, for example perhaps an i32.

Provided Methods

fn count_total(&self) -> Collection<G, (K, R), isize>

Counts the number of occurrences of each element.

Examples

use differential_dataflow::input::Input;
use differential_dataflow::operators::CountTotal;

::timely::example(|scope| {
    // report the number of occurrences of each key
    scope.new_collection_from(1 .. 10).1
         .map(|x| x / 3)
         .count_total();
});

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<G, K, T1> CountTotal<G, K, <T1 as TraceReader>::Diff> for Arranged<G, T1>

where G: Scope<Timestamp = T1::Time>, T1: for<'a> TraceReader<Val<'a> = &'a ()> + Clone + 'static, for<'a> T1::Key<'a>: IntoOwned<'a, Owned = K>, for<'a> T1::Diff: Semigroup<T1::DiffGat<'a>> + ExchangeData, K: ExchangeData, T1::Time: TotalOrder,

impl<G: Scope, K: ExchangeData + Hashable, R: ExchangeData + Semigroup> CountTotal<G, K, R> for Collection<G, K, R>

where G::Timestamp: TotalOrder + Lattice + Ord,