Struct rayon::par_iter::filter::Filter
[−]
[src]
pub struct Filter<M, FILTER_OP> { // some fields omitted }
Methods
impl<M, FILTER_OP> Filter<M, FILTER_OP>
[src]
Trait Implementations
impl<M, FILTER_OP> ParallelIterator for Filter<M, FILTER_OP> where M: ParallelIterator, FILTER_OP: Fn(&M::Item) -> bool + Sync
[src]
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>
Indicates the relative "weight" of producing each item in this parallel iterator. A higher weight will cause finer-grained parallel subtasks. 1.0 indicates something very cheap and uniform, like copying a value out of an array, or computing x + 1
. If your tasks are either very expensive, or very unpredictable, you are better off with higher values. See also weight_max
, which is a convenient shorthand to force the finest grained parallel execution posible. Tuning this value should not affect correctness but can improve (or hurt) performance. Read more
fn weight_max(self) -> Weight<Self>
Shorthand for self.weight(f64::INFINITY)
. This forces the smallest granularity of parallel execution, which makes sense when your parallel tasks are (potentially) very expensive to execute. Read more
fn for_each<OP>(self, op: OP) where OP: Fn(Self::Item) + Sync
Executes OP
on each item produced by the iterator, in parallel.
fn map<MAP_OP, R>(self, map_op: MAP_OP) -> Map<Self, MapFn<MAP_OP>> where MAP_OP: Fn(Self::Item) -> R + Sync
Applies map_op
to each item of this iterator, producing a new iterator with the results. Read more
fn cloned<'a, T>(self) -> Map<Self, MapCloned> where T: 'a + Clone, Self: ParallelIterator<Item=&'a T>
Creates an iterator which clones all of its elements. This may be useful when you have an iterator over &T
, but you need T
. Read more
fn inspect<INSPECT_OP>(self, inspect_op: INSPECT_OP) -> Map<Self, MapInspect<INSPECT_OP>> where INSPECT_OP: Fn(&Self::Item) + Sync
Applies inspect_op
to a reference to each item of this iterator, producing a new iterator passing through the original items. This is often useful for debugging to see what's happening in iterator stages. Read more
fn filter<FILTER_OP>(self, filter_op: FILTER_OP) -> Filter<Self, FILTER_OP> where FILTER_OP: Fn(&Self::Item) -> bool + Sync
Applies filter_op
to each item of this iterator, producing a new iterator with only the items that gave true
results. Read more
fn filter_map<FILTER_OP, R>(self, filter_op: FILTER_OP) -> FilterMap<Self, FILTER_OP> where FILTER_OP: Fn(Self::Item) -> Option<R> + Sync
Applies filter_op
to each item of this iterator to get an Option
, producing a new iterator with only the items from Some
results. Read more
fn flat_map<MAP_OP, PI>(self, map_op: MAP_OP) -> FlatMap<Self, MAP_OP> where MAP_OP: Fn(Self::Item) -> PI + Sync, PI: IntoParallelIterator
Applies map_op
to each item of this iterator to get nested iterators, producing a new iterator that flattens these back into one. Read more
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync
Reduces the items in the iterator into one item using op
. See also sum
, mul
, min
, etc, which are slightly more efficient. Returns None
if the iterator is empty. Read more
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
Reduces the items in the iterator into one item using op
. The argument identity
represents an "identity" value which may be inserted into the sequence as needed to create opportunities for parallel execution. So, for example, if you are doing a summation, then identity
ought to be something that represents the zero for your type (but consider just calling sum()
in that case). Read more
fn sum(self) -> Self::Item where SumOp: ReduceOp<Self::Item>
Sums up the items in the iterator. Read more
fn mul(self) -> Self::Item where MulOp: ReduceOp<Self::Item>
Multiplies all the items in the iterator. Read more
fn min(self) -> Self::Item where MinOp: ReduceOp<Self::Item>
Computes the minimum of all the items in the iterator. Read more
fn max(self) -> Self::Item where MaxOp: ReduceOp<Self::Item>
Computes the maximum of all the items in the iterator. Read more
fn reduce<REDUCE_OP>(self, reduce_op: &REDUCE_OP) -> Self::Item where REDUCE_OP: ReduceOp<Self::Item>
Reduces the items using the given "reduce operator". You may prefer reduce_with
for a simpler interface. Read more