Trait ParallelIterator 

pub trait ParallelIterator: Sized {
    type Item;

    // Required methods
    fn for_each<F>(self, f: F)
       where F: FnMut(Self::Item);
    fn map<F, R>(self, f: F) -> Map<Self, F>
       where F: Fn(Self::Item) -> R;
    fn filter<F>(self, f: F) -> Filter<Self, F>
       where F: Fn(&Self::Item) -> bool;
    fn collect<C>(self) -> C
       where C: FromParallelIterator<Self::Item>;
    fn sum<S>(self) -> S
       where S: Sum<Self::Item>;
    fn reduce<F>(self, reduce_op: F) -> Option<Self::Item>
       where F: Fn(Self::Item, Self::Item) -> Self::Item;
    fn find_any<F>(self, predicate: F) -> Option<Self::Item>
       where F: Fn(&Self::Item) -> bool;
    fn all<F>(self, predicate: F) -> bool
       where F: Fn(Self::Item) -> bool;
    fn any<F>(self, predicate: F) -> bool
       where F: Fn(Self::Item) -> bool;

    // Provided methods
    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 { ... }
    fn cloned<'a, T>(self) -> Cloned<Self>
       where Self: ParallelIterator<Item = &'a T>,
             T: 'a + Clone { ... }
    fn count<F>(self, predicate: F) -> usize
       where F: Fn(&Self::Item) -> bool { ... }
    fn partition<F>(self, predicate: F) -> (Vec<Self::Item>, Vec<Self::Item>)
       where F: Fn(&Self::Item) -> bool { ... }
}

Trait for parallel iterators

Required Associated Types

type Item

The type of item being iterated

Required Methods

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<F>(self, reduce_op: F) -> Option<Self::Item>

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

Reduce items with a reduction function

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

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

Find any item that matches the predicate

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

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

Check if all items match the predicate

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

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

Check if any item matches the predicate

Provided Methods

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

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<'a, I, T> ParallelIterator for Cloned<I>

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

type Item = T

impl<'a, T: 'a + Send> ParallelIterator for ParIterMut<'a, T>

type Item = &'a mut T

impl<'a, T: 'a + Sync> ParallelIterator for ParIter<'a, T>

type Item = &'a T

impl<I, F> ParallelIterator for Filter<I, F>

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

type Item = <I as ParallelIterator>::Item

impl<I, F, R> ParallelIterator for Map<I, F>

where I: ParallelIterator, F: Fn(I::Item) -> R,

type Item = R

impl<I, T, ID, F> ParallelIterator for Fold<I, ID, F>

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

type Item = T