Struct Par 

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

A parallel iterator.

Implementations

impl<I, R> Par<I, R>

where R: ParallelRunner, I: ConcurrentIter,

pub fn chain<C>( self, other: C, ) -> Par<ChainKnownLenI<I, <C as IntoConcurrentIter>::IntoIter>, R>

where I: ExactSizeConcurrentIter, C: IntoParIter<Item = <I as ConcurrentIter>::Item>,

Creates a chain of this and other parallel iterators.

The first iterator is required to have a known length for chaining.

Examples

use orx_parallel::*;

let a = vec!['a', 'b', 'c']; // with exact len
let b = vec!['d', 'e', 'f'].into_iter().filter(|x| *x != 'x');

let chain = a.into_par().chain(b.iter_into_par());
assert_eq!(
    chain.collect::<Vec<_>>(),
    vec!['a', 'b', 'c', 'd', 'e', 'f'],
);

Trait Implementations

impl<I> IntoConcurrentIter for Par<I>

where I: ConcurrentIter,

type Item = <I as ConcurrentIter>::Item

Type of the element that the concurrent iterator yields.

type IntoIter = I

Type of the concurrent iterator that this type can be converted into.

fn into_con_iter(self) -> <Par<I> as IntoConcurrentIter>::IntoIter

Trait to convert a source (collection or generator) into a concurrent iterator; i.e., ConcurrentIter, using its into_con_iter method.

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, orchestrator: Q, ) -> 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 using<U, F>( self, using: F, ) -> impl ParIterUsing<UsingFun<F, U>, R, Item = <Par<I, R> as ParIter<R>>::Item>

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

Converts the ParIter into ParIterUsing which will have access to a mutable reference of the used variable throughout the computation.

fn using_clone<U>( self, value: U, ) -> impl ParIterUsing<UsingClone<U>, R, Item = <Par<I, R> as ParIter<R>>::Item>

where U: Clone + 'static,

Converts the ParIter into ParIterUsing which will have access to a mutable reference of the used variable throughout the computation.

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

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

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 + 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, FlatMap: Fn(<Par<I, R> as ParIter<R>>::Item) -> IOut + 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 FilterMap: Fn(<Par<I, R> as ParIter<R>>::Item) -> Option<Out> + Sync,

Creates an iterator that both filters and maps.

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

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

Creates an iterator that yields elements based on the predicate take_while.

fn into_fallible_result<Out, Err>( self, ) -> impl ParIterResult<R, Item = Out, Err = Err>

where <Par<I, R> as ParIter<R>>::Item: IntoResult<Out, Err>,

Transforms a parallel iterator where elements are of the result type; i.e., ParIter<R, Item = Result<T, E>>, into fallible parallel iterator with item type T and error type E; i.e., into ParIterResult<R, Item = T, Err = E>.

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 <Par<I, R> as ParIter<R>>::Item: Send, Reduce: Fn(<Par<I, R> as ParIter<R>>::Item, <Par<I, R> as ParIter<R>>::Item) -> <Par<I, R> as ParIter<R>>::Item + 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 with_pool<P>( self, pool: P, ) -> impl ParIter<RunnerWithPool<P, <R as ParallelRunner>::Executor>, Item = Self::Item>

where P: ParThreadPool,

Rather than DefaultPool, uses the parallel runner with the given pool implementing ParThreadPool.

fn into_fallible_option<T>(self) -> impl ParIterOption<R, Item = T>

where Self::Item: IntoOption<T>,

Transforms a parallel iterator where elements are of the option type; i.e., ParIter<R, Item = Option<T>>, into fallible parallel iterator with item type T; i.e., into ParIterOption<R, Item = T>.

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

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

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

fn map_while<Out, MapWhile>( self, map_while: MapWhile, ) -> impl ParIter<R, Item = Out>

where MapWhile: Fn(Self::Item) -> Option<Out> + Sync + Clone,

Creates an iterator that both yields elements based on the predicate map_while and maps.

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

where T: 'a + Copy, 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, 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,

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 Self::Item: Send, Predicate: Fn(&Self::Item) -> bool + Sync,

Tests if every element of the iterator matches a predicate.

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

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

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,

Calls a closure on each element of an iterator.

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

where Self::Item: Ord + Send,

Returns the maximum element of an iterator.

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

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

Returns the minimum element of an iterator.

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

where Self::Item: Send, 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 Self::Item: Send, 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,

Sums the elements of an iterator.

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

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

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,