Struct ParOption 

pub struct ParOption<F, T, R = RunnerWithPool<SequentialPool>>
where
    R: ParallelRunner,
    F: ParIterResult<R, Item = T, Err = ()>,
{ /* private fields */ }

A parallel iterator for which the computation either completely succeeds, or fails and early exits with None.

Trait Implementations

impl<F, T, R> ParIterOption<R> for ParOption<F, T, R>

where R: ParallelRunner, F: ParIterResult<R, Item = T, Err = ()>,

type Item = T

Type of the success element, to be received as the Some variant iff the entire computation succeeds.

fn num_threads(self, num_threads: impl Into<NumThreads>) -> ParOption<F, T, 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>) -> ParOption<F, T, 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, order: IterationOrder) -> ParOption<F, T, R>

Sets the iteration order of the parallel computation.

fn with_runner<Q>( self, orchestrator: Q, ) -> impl ParIterOption<Q, Item = <ParOption<F, T, R> as ParIterOption<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 ParIterOption<R, Item = Out>

where Map: Fn(<ParOption<F, T, R> as ParIterOption<R>>::Item) -> Out + Sync + Clone, Out: Send,

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

fn filter<Filter>( self, filter: Filter, ) -> impl ParIterOption<R, Item = <ParOption<F, T, R> as ParIterOption<R>>::Item>

where ParOption<F, T, R>: Sized, Filter: Fn(&<ParOption<F, T, R> as ParIterOption<R>>::Item) -> bool + Sync + Clone, <ParOption<F, T, R> as ParIterOption<R>>::Item: Send,

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 ParIterOption<R, Item = <IOut as IntoIterator>::Item>

where ParOption<F, T, R>: Sized, IOut: IntoIterator, <IOut as IntoIterator>::Item: Send, FlatMap: Fn(<ParOption<F, T, R> as ParIterOption<R>>::Item) -> IOut + Sync + Clone,

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

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

where ParOption<F, T, R>: Sized, FilterMap: Fn(<ParOption<F, T, R> as ParIterOption<R>>::Item) -> Option<Out> + Sync + Clone, Out: Send,

Creates an iterator that both filters and maps.

fn inspect<Operation>( self, operation: Operation, ) -> impl ParIterOption<R, Item = <ParOption<F, T, R> as ParIterOption<R>>::Item>

where ParOption<F, T, R>: Sized, Operation: Fn(&<ParOption<F, T, R> as ParIterOption<R>>::Item) + Sync + Clone, <ParOption<F, T, R> as ParIterOption<R>>::Item: Send,

Does something with each successful element of an iterator, passing the value on, provided that all elements are of Some variant; short-circuits and returns None otherwise.

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

where <ParOption<F, T, R> as ParIterOption<R>>::Item: Send, C: ParCollectInto<<ParOption<F, T, R> as ParIterOption<R>>::Item>,

Collects all the items from an iterator into a collection iff all elements are of Some variant. Early exits and returns None if any of the elements is None.

fn collect<C>(self) -> Option<C>

where <ParOption<F, T, R> as ParIterOption<R>>::Item: Send, C: ParCollectInto<<ParOption<F, T, R> as ParIterOption<R>>::Item>,

Transforms an iterator into a collection iff all elements are of Ok variant. Early exits and returns the error if any of the elements is an Err.

fn reduce<Reduce>( self, reduce: Reduce, ) -> Option<Option<<ParOption<F, T, R> as ParIterOption<R>>::Item>>

where <ParOption<F, T, R> as ParIterOption<R>>::Item: Send, Reduce: Fn(<ParOption<F, T, R> as ParIterOption<R>>::Item, <ParOption<F, T, R> as ParIterOption<R>>::Item) -> <ParOption<F, T, R> as ParIterOption<R>>::Item + Sync,

Reduces the elements to a single one, by repeatedly applying a reducing operation. Early exits and returns None if any of the elements is None.

fn first(self) -> Option<Option<<ParOption<F, T, R> as ParIterOption<R>>::Item>>

where <ParOption<F, T, R> as ParIterOption<R>>::Item: Send,

Returns the first (or any) element of the iterator. If the iterator is empty, Some(None) is returned. Early exits and returns None if a None element is observed first.

fn with_pool<P>( self, pool: P, ) -> impl ParIterOption<RunnerWithPool<P, <R as ParallelRunner>::Executor>, Item = Self::Item>

where P: ParThreadPool, Self: Sized,

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

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

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

Tests if every element of the iterator matches a predicate. Early exits and returns None if any of the elements is None.

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

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

Tests if any element of the iterator matches a predicate. Early exits and returns None if any of the elements is None.

fn count(self) -> Option<usize>

where Self: Sized,

Consumes the iterator, counting the number of iterations and returning it. Early exits and returns None if any of the elements is None.

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

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

Calls a closure on each element of an iterator, and returns Ok(()) if all elements succeed. Early exits and returns None if any of the elements is None.

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

where Self: Sized, Self::Item: Ord + Send,

Returns Some of maximum element of an iterator if all elements succeed. If the iterator is empty, Some(None) is returned. Early exits and returns None if any of the elements is None.

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

where Self: Sized, 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. If the iterator is empty, Some(None) is returned. Early exits and returns None if any of the elements is None.

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

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

Returns the element that gives the maximum value from the specified function. If the iterator is empty, Some(None) is returned. Early exits and returns None if any of the elements is None.

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

where Self: Sized, Self::Item: Ord + Send,

Returns Some of minimum element of an iterator if all elements succeed. If the iterator is empty, Some(None) is returned. Early exits and returns None if any of the elements is None.

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

where Self: Sized, 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. If the iterator is empty, Some(None) is returned. Early exits and returns None if any of the elements is None.

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

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

Returns the element that gives the minimum value from the specified function. If the iterator is empty, Some(None) is returned. Early exits and returns None if any of the elements is None.

fn sum<Out>(self) -> Option<Out>

where Self: Sized, Self::Item: Sum<Out>, Out: Send,

Sums the elements of an iterator. Early exits and returns None if any of the elements is None.

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

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

Returns the first (or any) element of the iterator that satisfies the predicate. If the iterator is empty, Some(None) is returned. Early exits and returns None if a None element is observed first.