Struct rayon::par_iter::filter::Filter

pub struct Filter<M, FILTER_OP> {
    // some fields omitted
}

Methods

impl<M, FILTER_OP> Filter<M, FILTER_OP>

fn new(base: M, filter_op: FILTER_OP) -> Filter<M, FILTER_OP>

Trait Implementations

impl<M, FILTER_OP> ParallelIterator for Filter<M, FILTER_OP> where M: ParallelIterator, FILTER_OP: Fn(&M::Item) -> bool + Sync

type Item = M::Item

fn drive_unindexed<C>(self, consumer: C) -> C::Result where C: UnindexedConsumer<Self::Item>

fn weight(self, scale: f64) -> Weight<Self>

fn weight_max(self) -> Weight<Self>

fn for_each<OP>(self, op: OP) where OP: Fn(Self::Item) + Sync

fn map<MAP_OP, R>(self, map_op: MAP_OP) -> Map<Self, MAP_OP> where MAP_OP: Fn(Self::Item) -> R

fn filter<FILTER_OP>(self, filter_op: FILTER_OP) -> Filter<Self, FILTER_OP> where FILTER_OP: Fn(&Self::Item) -> bool

fn filter_map<FILTER_OP, R>(self, filter_op: FILTER_OP) -> FilterMap<Self, FILTER_OP> where FILTER_OP: Fn(Self::Item) -> Option<R>

fn flat_map<MAP_OP, PI>(self, map_op: MAP_OP) -> FlatMap<Self, MAP_OP> where MAP_OP: Fn(Self::Item) -> PI, PI: ParallelIterator

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync

fn reduce_with_identity<OP>(self, identity: Self::Item, op: OP) -> Self::Item where OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync, Self::Item: Clone + Sync

fn sum(self) -> Self::Item where SumOp: ReduceOp<Self::Item>

fn mul(self) -> Self::Item where MulOp: ReduceOp<Self::Item>

fn min(self) -> Self::Item where MinOp: ReduceOp<Self::Item>

fn max(self) -> Self::Item where MaxOp: ReduceOp<Self::Item>

fn reduce<REDUCE_OP>(self, reduce_op: &REDUCE_OP) -> Self::Item where REDUCE_OP: ReduceOp<Self::Item>

impl<M, FILTER_OP> BoundedParallelIterator for Filter<M, FILTER_OP> where M: BoundedParallelIterator, FILTER_OP: Fn(&M::Item) -> bool + Sync

fn upper_bound(&mut self) -> usize

fn drive<C>(self, consumer: C) -> C::Result where C: Consumer<Self::Item>