Trait kgdata::mapreduce::ParallelDataset

pub trait ParallelDataset: Sized + Send + IntoParallelIterator {
    // Provided methods
    fn map<F, R>(self, op: F) -> MapOp<Self, F>
       where F: Fn(Self::Item) -> R + Sync + Send,
             R: Send { ... }
    fn flat_map<F, R>(self, op: F) -> FlatMapOp<Self, F>
       where F: Fn(Self::Item) -> R + Sync + Send,
             R: IntoParallelIterator { ... }
    fn filter<F>(self, op: F) -> FilterOp<Self, F>
       where F: Fn(&Self::Item) -> bool + Sync { ... }
    fn fold<T, ID, F>(self, identity: ID, op: F) -> FoldOp<Self, ID, F>
       where F: Fn(T, Self::Item) -> T + Sync + Send,
             ID: Fn() -> T + Sync + Send,
             T: Send { ... }
    fn reduce<ID, F>(self, identity: ID, op: F) -> Self::Item
       where F: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
             ID: Fn() -> Self::Item + Sync + Send { ... }
    fn sort_by_key<F, K>(self, op: F, ascending: bool) -> SortByKeyOp<Self, F>
       where F: Fn(&Self::Item) -> K + Sync,
             K: Ord + Send { ... }
    fn group_by<F, K>(self, key: F) -> MapDataset<K, Vec<Self::Item>>
       where F: Fn(&Self::Item) -> K + Sync,
             K: Hash + Eq + Send { ... }
    fn group_by_map<K, V, F1, F2>(
        self,
        key: F1,
        value: F2
    ) -> MapDataset<K, Vec<V>>
       where F1: Fn(&Self::Item) -> K + Sync,
             F2: Fn(&Self::Item) -> V + Sync,
             K: Hash + Eq + Send,
             V: Send { ... }
    fn count(self) -> usize { ... }
    fn take_any(self, n: usize) -> TakeAny<Self> { ... }
    fn collect<C>(self) -> C
       where C: FromParallelDataset<Self::Item> { ... }
}

A note on the implementation: due to the trait methods required Sized on most of the methods, if we use as trait object, we can’t use most of its methods. To prevent early boxing error, we required it to be Sized.

Provided Methods

fn map<F, R>(self, op: F) -> MapOp<Self, F>

where F: Fn(Self::Item) -> R + Sync + Send, R: Send,

fn flat_map<F, R>(self, op: F) -> FlatMapOp<Self, F>

where F: Fn(Self::Item) -> R + Sync + Send, R: IntoParallelIterator,

fn filter<F>(self, op: F) -> FilterOp<Self, F>

where F: Fn(&Self::Item) -> bool + Sync,

fn fold<T, ID, F>(self, identity: ID, op: F) -> FoldOp<Self, ID, F>

where F: Fn(T, Self::Item) -> T + Sync + Send, ID: Fn() -> T + Sync + Send, T: Send,

fn reduce<ID, F>(self, identity: ID, op: F) -> Self::Item

where F: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, ID: Fn() -> Self::Item + Sync + Send,

fn sort_by_key<F, K>(self, op: F, ascending: bool) -> SortByKeyOp<Self, F>

where F: Fn(&Self::Item) -> K + Sync, K: Ord + Send,

fn group_by<F, K>(self, key: F) -> MapDataset<K, Vec<Self::Item>>

where F: Fn(&Self::Item) -> K + Sync, K: Hash + Eq + Send,

fn group_by_map<K, V, F1, F2>(self, key: F1, value: F2) -> MapDataset<K, Vec<V>>

where F1: Fn(&Self::Item) -> K + Sync, F2: Fn(&Self::Item) -> V + Sync, K: Hash + Eq + Send, V: Send,

fn count(self) -> usize

fn take_any(self, n: usize) -> TakeAny<Self>

fn collect<C>(self) -> C

where C: FromParallelDataset<Self::Item>,

Object Safety

This trait is not object safe.

Implementors

impl<'t, I> ParallelDataset for RefDataset<'t, I>

where I: Sync + 't,

impl<D> ParallelDataset for TakeAny<D>

where D: ParallelDataset,

impl<D, F> ParallelDataset for FilterOp<D, F>

where D: ParallelDataset, F: Fn(&D::Item) -> bool + Sync + Send,

impl<D, F, PI> ParallelDataset for FlatMapOp<D, F>

where D: ParallelDataset, F: Fn(D::Item) -> PI + Sync + Send, PI: IntoParallelIterator,

impl<D, F, R> ParallelDataset for MapOp<D, F>

where D: ParallelDataset, F: Fn(D::Item) -> R + Sync + Send, R: Send,

impl<D, T, ID, F> ParallelDataset for FoldOp<D, ID, F>

where D: ParallelDataset, F: Fn(T, D::Item) -> T + Sync + Send, ID: Fn() -> T + Sync + Send, T: Send,

impl<I> ParallelDataset for Dataset<I>

where I: Send,

impl<K, V> ParallelDataset for MapDataset<K, V>

where K: Hash + Eq + Send, V: Send,