Trait ReduceExt

pub trait ReduceExt<G: Scope, Tr: TraceReader<Time = G::Timestamp>>
where
    G::Timestamp: Lattice + Ord,
{
    // Required method
    fn reduce_pair<L1, K, V1, Bu1, T1, L2, V2, Bu2, T2>(
        &self,
        name1: &str,
        name2: &str,
        logic1: L1,
        logic2: L2,
    ) -> (Arranged<G, TraceAgent<T1>>, Arranged<G, TraceAgent<T2>>)
       where K: Data,
             T1: Trace + for<'a> TraceReader<Key<'a> = Tr::Key<'a>, Time = G::Timestamp> + 'static,
             for<'a> T1::Key<'a>: IntoOwned<'a, Owned = K>,
             for<'a> T1::Val<'a>: IntoOwned<'a, Owned = V1>,
             T1::Diff: Abelian,
             T1::Batch: Batch,
             Bu1: Builder<Time = G::Timestamp, Output = T1::Batch>,
             Bu1::Input: Container + PushInto<((K, V1), T1::Time, T1::Diff)>,
             L1: FnMut(Tr::Key<'_>, &[(Tr::Val<'_>, Tr::Diff)], &mut Vec<(V1, T1::Diff)>) + 'static,
             V1: Data,
             T2: Trace + for<'a> TraceReader<Key<'a> = Tr::Key<'a>, Time = G::Timestamp> + 'static,
             for<'a, 'a> T2::Val<'a>: IntoOwned<'a, Owned = V2>,
             T2::Diff: Abelian,
             T2::Batch: Batch,
             Bu2: Builder<Time = G::Timestamp, Output = T2::Batch>,
             Bu2::Input: Container + PushInto<((K, V2), T2::Time, T2::Diff)>,
             L2: FnMut(Tr::Key<'_>, &[(Tr::Val<'_>, Tr::Diff)], &mut Vec<(V2, T2::Diff)>) + 'static,
             V2: Data,
             Arranged<G, TraceAgent<T1>>: ArrangementSize,
             Arranged<G, TraceAgent<T2>>: ArrangementSize;
}

Extension trait for ReduceCore, currently providing a reduction based on an operator-pair approach.

Required Methods

fn reduce_pair<L1, K, V1, Bu1, T1, L2, V2, Bu2, T2>( &self, name1: &str, name2: &str, logic1: L1, logic2: L2, ) -> (Arranged<G, TraceAgent<T1>>, Arranged<G, TraceAgent<T2>>)

where K: Data, T1: Trace + for<'a> TraceReader<Key<'a> = Tr::Key<'a>, Time = G::Timestamp> + 'static, for<'a> T1::Key<'a>: IntoOwned<'a, Owned = K>, for<'a> T1::Val<'a>: IntoOwned<'a, Owned = V1>, T1::Diff: Abelian, T1::Batch: Batch, Bu1: Builder<Time = G::Timestamp, Output = T1::Batch>, Bu1::Input: Container + PushInto<((K, V1), T1::Time, T1::Diff)>, L1: FnMut(Tr::Key<'_>, &[(Tr::Val<'_>, Tr::Diff)], &mut Vec<(V1, T1::Diff)>) + 'static, V1: Data, T2: Trace + for<'a> TraceReader<Key<'a> = Tr::Key<'a>, Time = G::Timestamp> + 'static, for<'a, 'a> T2::Val<'a>: IntoOwned<'a, Owned = V2>, T2::Diff: Abelian, T2::Batch: Batch, Bu2: Builder<Time = G::Timestamp, Output = T2::Batch>, Bu2::Input: Container + PushInto<((K, V2), T2::Time, T2::Diff)>, L2: FnMut(Tr::Key<'_>, &[(Tr::Val<'_>, Tr::Diff)], &mut Vec<(V2, T2::Diff)>) + 'static, V2: Data, Arranged<G, TraceAgent<T1>>: ArrangementSize, Arranged<G, TraceAgent<T2>>: ArrangementSize,

This method produces a reduction pair based on the same input arrangement. Each reduction in the pair operates with its own logic and the two output arrangements from the reductions are produced as a result. The method is useful for reductions that need to present different output views on the same input data. An example is producing an error-free reduction output along with a separate error output indicating when the error-free output is valid.

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.

Implementations on Foreign Types

impl<G: Scope, Tr> ReduceExt<G, Tr> for Arranged<G, Tr>

where G::Timestamp: Lattice + Ord, Tr: TraceReader<Time = G::Timestamp> + Clone + 'static, Tr::Diff: Semigroup,

fn reduce_pair<L1, K, V1, Bu1, T1, L2, V2, Bu2, T2>( &self, name1: &str, name2: &str, logic1: L1, logic2: L2, ) -> (Arranged<G, TraceAgent<T1>>, Arranged<G, TraceAgent<T2>>)

where K: Data, T1: Trace + for<'a> TraceReader<Key<'a> = Tr::Key<'a>, Time = G::Timestamp> + 'static, for<'a> T1::Key<'a>: IntoOwned<'a, Owned = K>, for<'a> T1::Val<'a>: IntoOwned<'a, Owned = V1>, T1::Diff: Abelian, T1::Batch: Batch, Bu1: Builder<Time = G::Timestamp, Output = T1::Batch>, Bu1::Input: Container + PushInto<((K, V1), T1::Time, T1::Diff)>, L1: FnMut(Tr::Key<'_>, &[(Tr::Val<'_>, Tr::Diff)], &mut Vec<(V1, T1::Diff)>) + 'static, V1: Data, T2: Trace + for<'a> TraceReader<Key<'a> = Tr::Key<'a>, Time = G::Timestamp> + 'static, for<'a, 'a> T2::Val<'a>: IntoOwned<'a, Owned = V2>, T2::Diff: Abelian, T2::Batch: Batch, Bu2: Builder<Time = G::Timestamp, Output = T2::Batch>, Bu2::Input: Container + PushInto<((K, V2), T2::Time, T2::Diff)>, L2: FnMut(Tr::Key<'_>, &[(Tr::Val<'_>, Tr::Diff)], &mut Vec<(V2, T2::Diff)>) + 'static, V2: Data, Arranged<G, TraceAgent<T1>>: ArrangementSize, Arranged<G, TraceAgent<T2>>: ArrangementSize,

Implementors