Struct kgdata::mapreduce::foldop::FoldOp

pub struct FoldOp<D: ParallelDataset, ID, F> {
    pub base: D,
    pub identity: ID,
    pub op: F,
}

Fields

base: D

identity: ID

op: F

Trait Implementations

impl<D: Clone + ParallelDataset, ID: Clone, F: Clone> Clone for FoldOp<D, ID, F>

fn clone(&self) -> FoldOp<D, ID, F>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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

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

type Iter = Fold<<D as IntoParallelIterator>::Iter, ID, F>

The parallel iterator type that will be created.

type Item = T

The type of item that the parallel iterator will produce.

fn into_par_iter(self) -> Self::Iter

Converts self into a parallel iterator.

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,

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>,