Struct Filter 

pub struct Filter<I, F> { /* private fields */ }

Filter adapter for parallel iterators

Trait Implementations

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

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

type Item = <I as ParallelIterator>::Item

The type of item being iterated

fn for_each<G>(self, g: G)

where G: FnMut(Self::Item),

Execute a function on each item (sequential for now)

fn map<G, R>(self, g: G) -> Map<Self, G>

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

Map each item (sequential for now)

fn filter<G>(self, g: G) -> Filter<Self, G>

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

where RED: 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