Struct Par

pub struct Par<I, R = FixedChunkRunner>
where
    R: ParallelRunner,
    I: ConcurrentIter,
{ /* private fields */ }

A parallel iterator.

Trait Implementations

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

where R: ParallelRunner, I: ConcurrentIter,

type Item = <I as ConcurrentIter>::Item

Element type of the parallel iterator.

fn con_iter(&self) -> &impl ConcurrentIter

Returns a reference to the input concurrent iterator.

fn params(&self) -> &Params

Parameters of the parallel iterator.

fn num_threads(self, num_threads: impl Into<NumThreads>) -> Par<I, R>

Sets the number of threads to be used in the parallel execution. Integers can be used as the argument with the following mapping:

fn chunk_size(self, chunk_size: impl Into<ChunkSize>) -> Par<I, R>

Sets the number of elements to be pulled from the concurrent iterator during the parallel execution. When integers are used as argument, the following mapping applies:

fn iteration_order(self, collect: IterationOrder) -> Par<I, R>

Sets the iteration order of the parallel computation.

fn with_runner<Q>( self, ) -> impl ParIter<Q, Item = <Par<I, R> as ParIter<R>>::Item>

where Q: ParallelRunner,

Rather than the DefaultRunner, uses the parallel runner Q which implements ParallelRunner.

fn map<Out, Map>(self, map: Map) -> impl ParIter<R, Item = Out>

where Out: Send + Sync, Map: Fn(<Par<I, R> as ParIter<R>>::Item) -> Out + Send + Sync + Clone,

Takes a closure map and creates a parallel iterator which calls that closure on each element.

fn filter<Filter>( self, filter: Filter, ) -> impl ParIter<R, Item = <Par<I, R> as ParIter<R>>::Item>

where Filter: Fn(&<Par<I, R> as ParIter<R>>::Item) -> bool + Send + Sync,

Creates an iterator which uses a closure filter to determine if an element should be yielded.

fn flat_map<IOut, FlatMap>( self, flat_map: FlatMap, ) -> impl ParIter<R, Item = <IOut as IntoIterator>::Item>

where IOut: IntoIterator + Send + Sync, <IOut as IntoIterator>::IntoIter: Send + Sync, <IOut as IntoIterator>::Item: Send + Sync, FlatMap: Fn(<Par<I, R> as ParIter<R>>::Item) -> IOut + Send + Sync,

Creates an iterator that works like map, but flattens nested structure.

fn filter_map<Out, FilterMap>( self, filter_map: FilterMap, ) -> impl ParIter<R, Item = Out>

where Out: Send + Sync, FilterMap: Fn(<Par<I, R> as ParIter<R>>::Item) -> Option<Out> + Send + Sync + Clone,

Creates an iterator that both filters and maps.

fn collect_into<C>(self, output: C) -> C

where C: ParCollectInto<<Par<I, R> as ParIter<R>>::Item>,

Collects all the items from an iterator into a collection.

fn reduce<Reduce>( self, reduce: Reduce, ) -> Option<<Par<I, R> as ParIter<R>>::Item>

where Reduce: Fn(<Par<I, R> as ParIter<R>>::Item, <Par<I, R> as ParIter<R>>::Item) -> <Par<I, R> as ParIter<R>>::Item + Send + Sync,

Reduces the elements to a single one, by repeatedly applying a reducing operation.

fn first(self) -> Option<<Par<I, R> as ParIter<R>>::Item>

Returns the first (or any) element of the iterator; returns None if it is empty.

fn inspect<Operation>( self, operation: Operation, ) -> impl ParIter<R, Item = Self::Item>

where Operation: Fn(&Self::Item) + Sync + Send + Clone,

Does something with each element of an iterator, passing the value on.

fn copied<'a, T>(self) -> impl ParIter<R, Item = T>

where T: 'a + Copy + Send + Sync, Self: ParIter<R, Item = &'a T>,

Creates an iterator which copies all of its elements.

fn cloned<'a, T>(self) -> impl ParIter<R, Item = T>

where T: 'a + Clone + Send + Sync, Self: ParIter<R, Item = &'a T>,

Creates an iterator which clones all of its elements.

fn flatten(self) -> impl ParIter<R, Item = <Self::Item as IntoIterator>::Item>

where Self::Item: IntoIterator, <Self::Item as IntoIterator>::IntoIter: Send + Sync, <Self::Item as IntoIterator>::Item: Send + Sync, R: Send + Sync, Self: Send + Sync,

Creates an iterator that flattens nested structure.

fn collect<C>(self) -> C

where C: ParCollectInto<Self::Item>,

Transforms an iterator into a collection.

fn all<Predicate>(self, predicate: Predicate) -> bool

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

Tests if every element of the iterator matches a predicate.

fn any<Predicate>(self, predicate: Predicate) -> bool

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

Tests if any element of the iterator matches a predicate.

fn count(self) -> usize

Consumes the iterator, counting the number of iterations and returning it.

fn for_each<Operation>(self, operation: Operation)

where Operation: Fn(Self::Item) + Sync + Send,

Calls a closure on each element of an iterator.

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

where Self::Item: Ord,

Returns the maximum element of an iterator.

fn max_by<Compare>(self, compare: Compare) -> Option<Self::Item>

where Compare: Fn(&Self::Item, &Self::Item) -> Ordering + Sync,

Returns the element that gives the maximum value with respect to the specified compare function.

fn max_by_key<Key, GetKey>(self, key: GetKey) -> Option<Self::Item>

where Key: Ord, GetKey: Fn(&Self::Item) -> Key + Sync,

Returns the element that gives the maximum value from the specified function.

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

where Self::Item: Ord,

Returns the minimum element of an iterator.

fn min_by<Compare>(self, compare: Compare) -> Option<Self::Item>

where Compare: Fn(&Self::Item, &Self::Item) -> Ordering + Sync,

Returns the element that gives the minimum value with respect to the specified compare function.

fn min_by_key<Key, GetKey>(self, get_key: GetKey) -> Option<Self::Item>

where Key: Ord, GetKey: Fn(&Self::Item) -> Key + Sync,

Returns the element that gives the minimum value from the specified function.

fn sum<Out>(self) -> Out

where Self::Item: Sum<Out>, Out: Send + Sync,

Sums the elements of an iterator.

fn find<Predicate>(self, predicate: Predicate) -> Option<Self::Item>

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

Searches for an element of an iterator that satisfies a predicate.

impl<I, R> Send for Par<I, R>

where R: ParallelRunner, I: ConcurrentIter,

impl<I, R> Sync for Par<I, R>

where R: ParallelRunner, I: ConcurrentIter,