Struct ParIter 

pub struct ParIter<I, X, R = AdaptiveChunkRunner<DefaultPool>>
where
    I: ConcurrentIter,
    X: Xap<I = I::Item>,
    R: ParRunner,
{ /* private fields */ }

Parallel iterator.

Trait Implementations

impl<I, X, R> IntoIterator for ParIter<I, X, R>

where I: ConcurrentIter, X: Xap<I = I::Item>, R: ParRunner,

type Item = <X as Xap>::O

The type of the elements being iterated over.

type IntoIter = XapIter<<I as ConcurrentIter>::SequentialIter, X>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<I, X, R> Par for ParIter<I, X, R>

where I: ConcurrentIter, X: Xap<I = I::Item>, R: ParRunner,

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

Replaces the current parallel runner with runner.

fn runner_with_diagnostics( self, ) -> impl Par<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 Par<Item = Q, Xap = MapOf<Self::Xap, Q, H>, Input = Self::Input>

where H: Fn(X::O) -> Q + Copy + Send,

Maps each element with closure h.

fn inspect<H>( self, h: H, ) -> impl Par<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 Par<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 Par<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 Par<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 Par<Item = <Self::Item as IntoIterator>::Item, Xap = FlattenOf<Self::Xap>, Input = Self::Input>

where Self::Item: IntoIterator,

Flattens one level of nested iterables.

fn size_hint(&self) -> (usize, Option<usize>)

Returns a lower and optional upper bound on the number of output items.

fn first(self) -> Option<X::O>

where X::O: Send,

Returns the first item according to iteration order, or None if empty.

fn reduce<F>(self, f: F) -> Option<X::O>

where F: Fn(X::O, X::O) -> X::O + Send + Copy, X::O: Send,

Reduces items into one value using associative reducer f.

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

where P: ParExtend<X::O>, X::O: Send,

Collects all items into dst.

fn into_optional<T>( self, ) -> impl ParOption<Elem = T, Xap1 = Self::Xap, M = T, Xap2 = Id<T>, Input = Self::Input, Size = <<Self::Xap as Xap>::Size as Size>::IntoPair>

where Self::Xap: Xap<O = Option<T>>,

Converts Par<Item = Option<T>> into ParOption<Item = T>.

fn into_fallible<T, E>( self, ) -> impl ParResult<Elem = T, Error = E, Xap1 = Self::Xap, M = T, Xap2 = Id<T>, Input = Self::Input, Size = <<Self::Xap as Xap>::Size as Size>::IntoPair>

where Self::Xap: Xap<O = Result<T, E>>,

Converts Par<Item = Result<T, E>> into ParResult<Item = T, Error = E>.

fn use_new<U, F>( self, f: F, ) -> impl ParUse<Item = Self::Item, Use = U, Xap = IdUse<Self::Xap, U>, Input = Self::Input>

where U: Send, F: Fn(usize) -> U + Sync,

Creates one mutable Use value per participating worker.

fn use_vec<U, F>( self, use_vec: &mut UseVec<U, F>, ) -> impl ParUse<Item = Self::Item, Use = U, Xap = IdUse<Self::Xap, U>, Input = Self::Input>

where U: Send, F: Fn(usize) -> U + Sync,

Uses an externally owned UseVec as worker-local mutable state.

fn use_slice<'a, U>( self, slice: &'a mut [U], ) -> impl ParUse<Item = Self::Item, Use = U, Xap = IdUse<Self::Xap, U>, Input = Self::Input>

where U: Send + 'a,

Uses a caller-provided mutable slice as worker-local mutable state.

fn copied<'a, O>( self, ) -> impl Par<Item = O, Xap = MappedOf<Self::Xap, FnCopied<'a, O>>, Input = Self::Input>

where Self: Par<Item = &'a O>, O: Copy + 'a,

Copies elements of a reference iterator.

fn cloned<'a, O>( self, ) -> impl Par<Item = O, Xap = MappedOf<Self::Xap, FnCloned<'a, O>>, Input = Self::Input>

where Self: Par<Item = &'a O>, O: Clone + 'a,

Clones elements of a reference iterator.

fn len(&self) -> usize

where Self::Input: ExactSizeConcurrentIter, Self::Xap: Xap<Size = One>,

Returns the exact number of output items.

fn is_empty(&self) -> bool

where Self::Input: ExactSizeConcurrentIter, Self::Xap: Xap<Size = One>,

Returns true when the parallel iterator has no output items.

fn collect<P>(self) -> P

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

Collects all items into a new collection.

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

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

Returns true if all items satisfy predicate f.

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

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

Returns true if any item satisfies predicate f.

fn count(self) -> usize

Counts elements.

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

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

Finds first (Ordered, default) or any (Arbitrary) item satisfying predicate f.

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

where B: Send, I: Fn() -> B + Sync, F: Fn(&mut B, Self::Item) + Copy + Send,

Folds elements into per-thread accumulators and returns them.

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

where F: Fn(Self::Item) + Send + Copy,

Executes f for each item.

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

where Self::Item: Ord + 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 + Sync,

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 + Sync,

Returns element with maximum key value.

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

where Self::Item: Ord + 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 + Sync,

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 + Sync,

Returns element with minimum key value.

fn sum<S>(self) -> S

where Self::Item: Sum<S>, S: Send,

Sums elements using Sum implementation of the item type.