Struct Cloned 

pub struct Cloned<I> { /* private fields */ }

Cloned adapter for parallel iterators over references

Trait Implementations

impl<'a, I, T> ParallelIterator for Cloned<I>

where I: ParallelIterator<Item = &'a T>, T: 'a + Clone,

type Item = T

The type of item being iterated

fn for_each<F>(self, f: F)

where F: FnMut(Self::Item),

Execute a function on each item (sequential for now)

fn map<F, R>(self, f: F) -> Map<Self, F>

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

Map each item (sequential for now)

fn filter<F>(self, f: F) -> Filter<Self, F>

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

Filter items (sequential for now)

fn collect<C>(self) -> C

where C: FromParallelIterator<Self::Item>,

Collect into a collection

fn sum<S>(self) -> S

where S: Sum<Self::Item>,

Sum all items

fn reduce<R>(self, reduce_op: R) -> Option<Self::Item>

where R: Fn(Self::Item, Self::Item) -> Self::Item,

Reduce items with a reduction function

fn find_any<P>(self, predicate: P) -> Option<Self::Item>

where P: Fn(&Self::Item) -> bool,

Find any item that matches the predicate

fn all<P>(self, predicate: P) -> bool

where P: Fn(Self::Item) -> bool,

Check if all items match the predicate

fn any<P>(self, predicate: P) -> bool

where P: Fn(Self::Item) -> bool,

Check if any item matches the predicate

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F>

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

Fold items with an identity value and accumulator function

fn cloned<'a, T>(self) -> Cloned<Self>

where Self: ParallelIterator<Item = &'a T>, T: 'a + Clone,

Clone all items (for reference iterators)

fn count<F>(self, predicate: F) -> usize

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

Count items matching predicate

fn partition<F>(self, predicate: F) -> (Vec<Self::Item>, Vec<Self::Item>)

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

Partition items based on predicate