Struct ParRecIter 

pub struct ParRecIter<I, X, Ix, Ex, R = AdaptiveChunkRunner<DefaultPool>>
where
    I: IntoIterator,
    X: Xap<I = I::Item>,
    R: ParRunner,
    Ix: IntoIterator<Item = X::I>,
    Ex: Fn(&I::Item) -> Ix + Send + Copy,
{ /* private fields */ }

Parallel iterator.

Trait Implementations

impl<I, X, Ix, Ex, R> ParRec for ParRecIter<I, X, Ix, Ex, R>

where I: IntoIterator, X: Xap<I = I::Item>, R: ParRunner, Ix: IntoIterator<Item = X::I>, Ex: Fn(&I::Item) -> Ix + Send + Copy,

fn runner<Q: ParRunner>( self, runner: Q, ) -> impl ParRec<Item = Self::Item, Xap = Self::Xap, Input = Self::Input>

Replaces the current parallel runner with runner.

fn runner_with_diagnostics( self, ) -> impl ParRec<Item = Self::Item, Xap = Self::Xap, Input = Self::Input>

Wraps the current parallel runner with a diagnostics-enabled runner.

fn num_threads(self, num_threads: impl Into<NumThreads>) -> Self

Sets the maximum number of worker threads for this computation.

fn chunk_size(self, chunk_size: impl Into<ChunkSize>) -> Self

Sets chunk size used when pulling items from the concurrent input.

fn iteration_order(self, collect: IterationOrder) -> Self

Sets iteration order semantics for operations sensitive to ordering.

fn map<Q, H>( self, h: H, ) -> impl ParRec<Item = Q, Xap = MapOf<Self::Xap, Q, H>, Input = Self::Input>

where H: Fn(Self::Item) -> Q + Copy + Send,

Maps each element with closure h.

fn inspect<H>( self, h: H, ) -> impl ParRec<Item = Self::Item, Xap = InsOf<Self::Xap, H>, Input = Self::Input>

where H: Fn(&Self::Item) + Copy + Send,

Runs h on each element and forwards the item unchanged.

fn filter<H>( self, h: H, ) -> impl ParRec<Item = Self::Item, Xap = FilOf<Self::Xap, H>, Input = Self::Input>

where H: Fn(&Self::Item) -> bool + Copy + Send,

Keeps only elements satisfying predicate h.

fn filter_map<Q, H>( self, h: H, ) -> impl ParRec<Item = Q, Xap = FilMapOf<Self::Xap, Q, H>, Input = Self::Input>

where H: Fn(Self::Item) -> Option<Q> + Copy + Send,

Maps and filters in a single pass.

fn flat_map<V, H>( self, h: H, ) -> impl ParRec<Item = V::Item, Xap = FlatMapOf<Self::Xap, V, H>, Input = Self::Input>

where V: IntoIterator, H: Fn(Self::Item) -> V + Copy + Send,

Maps each element to an iterator and flattens one level.

fn flatten( self, ) -> impl ParRec<Item = <Self::Item as IntoIterator>::Item, Xap = FlattenOf<Self::Xap>, Input = Self::Input>

where Self::Item: IntoIterator,

Flattens one level of nested iterables.

fn first(self) -> Option<Self::Item>

where Self::Item: Send, <Self::Input as IntoIterator>::Item: Send,

Returns an item, or None if empty.

fn reduce<F>(self, f: F) -> Option<Self::Item>

where F: Fn(Self::Item, Self::Item) -> Self::Item + Send + Copy, Self::Item: Send, <Self::Input as IntoIterator>::Item: Send,

Reduces items into one value using associative reducer f.

fn fold<B, Id, F>(self, init: Id, f: F) -> Vec<B>

where B: Send, Id: Fn() -> B, F: Fn(&mut B, Self::Item) + Copy + Send, <Self::Input as IntoIterator>::Item: Send,

Folds elements into per-thread accumulators and returns them.

fn collect_into<C>(self, dst: &mut C)

where C: ParExtend<Self::Item>, Self::Item: Send, <Self::Input as IntoIterator>::Item: Send,

Collects all items into dst.

fn collect<P>(self) -> P

where P: ParExtend<Self::Item> + Default, Self::Item: Send, <Self::Input as IntoIterator>::Item: Send,

Collects all items into a new collection.

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

where F: Fn(&Self::Item) -> bool + Copy + Send, <Self::Input as IntoIterator>::Item: Send,

Returns true if all items satisfy predicate f.

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

where F: Fn(&Self::Item) -> bool + Copy + Send, <Self::Input as IntoIterator>::Item: Send,

Returns true if any item satisfies predicate f.

fn count(self) -> usize

where <Self::Input as IntoIterator>::Item: Send,

Counts elements.

fn find<F>(self, f: F) -> Option<Self::Item>

where Self::Item: Send, F: Fn(&Self::Item) -> bool + Copy + Send, <Self::Input as IntoIterator>::Item: Send,

Finds the first item satisfying predicate f, or None if none match.

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

where F: Fn(Self::Item) + Send + Copy, <Self::Input as IntoIterator>::Item: Send,

Executes f for each item.

fn max(self) -> Option<Self::Item>

where Self::Item: Ord + Send, <Self::Input as IntoIterator>::Item: Send,

Returns maximum element, or None if empty.

fn max_by<F>(self, f: F) -> Option<Self::Item>

where Self::Item: Send, F: Fn(&Self::Item, &Self::Item) -> Ordering + Copy + Send, <Self::Input as IntoIterator>::Item: Send,

Returns element considered maximum by comparator f.

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>

where Self::Item: Send, B: Ord, F: Fn(&Self::Item) -> B + Copy + Send, <Self::Input as IntoIterator>::Item: Send,

Returns element with maximum key value.

fn min(self) -> Option<Self::Item>

where Self::Item: Ord + Send, <Self::Input as IntoIterator>::Item: Send,

Returns minimum element, or None if empty.

fn min_by<F>(self, f: F) -> Option<Self::Item>

where Self::Item: Send, F: Fn(&Self::Item, &Self::Item) -> Ordering + Copy + Send, <Self::Input as IntoIterator>::Item: Send,

Returns element considered minimum by comparator f.

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>

where Self::Item: Send, B: Ord, F: Fn(&Self::Item) -> B + Copy + Send, <Self::Input as IntoIterator>::Item: Send,

Returns element with minimum key value.

fn sum<S>(self) -> S

where Self::Item: Sum<S>, S: Send, <Self::Input as IntoIterator>::Item: Send,

Sums elements using Sum implementation of the item type.