Struct ParResult 

pub struct ParResult<I, T, E, R = RunnerWithPool<SequentialPool>>
where
    R: ParallelRunner,
    I: ConcurrentIter,
    <I as ConcurrentIter>::Item: IntoResult<T, E>,
{ /* private fields */ }

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

Trait Implementations

impl<I, T, E, R> ParIterResult<R> for ParResult<I, T, E, R>

where R: ParallelRunner, I: ConcurrentIter, <I as ConcurrentIter>::Item: IntoResult<T, E>,

type Item = T

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

type Err = E

Type of the Err element, to be received if any of the computations fails.

type RegularItem = <I as ConcurrentIter>::Item

Element type of the regular parallel iterator this fallible iterator can be converted to, simply Result<Self::Ok, Self::Err>.

type RegularParIter = Par<I, R>

Regular parallel iterator this fallible iterator can be converted into.

fn con_iter_len(&self) -> Option<usize>

Returns a reference to the input concurrent iterator.

fn into_regular_par( self, ) -> <ParResult<I, T, E, R> as ParIterResult<R>>::RegularParIter

Converts this fallible iterator into a regular parallel iterator; i.e., ParIter, with Item = Result<Self::Ok, Self::Err>.

fn from_regular_par( regular_par: <ParResult<I, T, E, R> as ParIterResult<R>>::RegularParIter, ) -> ParResult<I, T, E, R>

Converts the regular_par iterator with Item = Result<Self::Ok, Self::Err> into fallible result iterator.

fn with_runner<Q>( self, orchestrator: Q, ) -> impl ParIterResult<Q, Item = <ParResult<I, T, E, R> as ParIterResult<R>>::Item, Err = <ParResult<I, T, E, R> as ParIterResult<R>>::Err>

where Q: ParallelRunner,

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

fn collect_into<C>( self, output: C, ) -> Result<C, <ParResult<I, T, E, R> as ParIterResult<R>>::Err>

where C: ParCollectInto<<ParResult<I, T, E, R> as ParIterResult<R>>::Item>, <ParResult<I, T, E, R> as ParIterResult<R>>::Item: Send, <ParResult<I, T, E, R> as ParIterResult<R>>::Err: Send,

Collects all the items from 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, ) -> Result<Option<<ParResult<I, T, E, R> as ParIterResult<R>>::Item>, <ParResult<I, T, E, R> as ParIterResult<R>>::Err>

where <ParResult<I, T, E, R> as ParIterResult<R>>::Item: Send, <ParResult<I, T, E, R> as ParIterResult<R>>::Err: Send, Reduce: Fn(<ParResult<I, T, E, R> as ParIterResult<R>>::Item, <ParResult<I, T, E, R> as ParIterResult<R>>::Item) -> <ParResult<I, T, E, R> as ParIterResult<R>>::Item + Sync,

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

fn first( self, ) -> Result<Option<<ParResult<I, T, E, R> as ParIterResult<R>>::Item>, <ParResult<I, T, E, R> as ParIterResult<R>>::Err>

where <ParResult<I, T, E, R> as ParIterResult<R>>::Item: Send, <ParResult<I, T, E, R> as ParIterResult<R>>::Err: Send,

Returns the first (or any) element of the iterator. If the iterator is empty, Ok(None) is returned. Early exits and returns the error if an Err element is observed first.

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

where Self: Sized,

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>) -> Self

where Self: Sized,

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) -> Self

where Self: Sized,

Sets the iteration order of the parallel computation.

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

where P: ParThreadPool, Self: Sized,

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

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

where Self: Sized, Map: Fn(Self::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 ParIterResult<R, Item = Self::Item, Err = Self::Err>

where Self: Sized, Filter: Fn(&Self::Item) -> bool + Sync + Clone, Self::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 ParIterResult<R, Item = <IOut as IntoIterator>::Item, Err = Self::Err>

where Self: Sized, IOut: IntoIterator, <IOut as IntoIterator>::Item: Send, FlatMap: Fn(Self::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 ParIterResult<R, Item = Out, Err = Self::Err>

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

Creates an iterator that both filters and maps.

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

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

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

fn collect<C>(self) -> Result<C, Self::Err>

where Self: Sized, Self::Item: Send, Self::Err: Send, C: ParCollectInto<Self::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 all<Predicate>(self, predicate: Predicate) -> Result<bool, Self::Err>

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

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

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

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

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

fn count(self) -> Result<usize, Self::Err>

where Self: Sized, Self::Err: Send,

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

fn for_each<Operation>(self, operation: Operation) -> Result<(), Self::Err>

where Self: Sized, Self::Err: Send, 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 the error if any of the elements is an Err.

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

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

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

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

where Self: Sized, Self::Item: Send, Self::Err: 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, Ok(None) is returned. Early exits and returns the error if any of the elements is an Err.

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

where Self: Sized, Self::Item: Send, Self::Err: 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, Ok(None) is returned. Early exits and returns the error if any of the elements is an Err.

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

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

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

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

where Self: Sized, Self::Item: Send, Self::Err: 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, Ok(None) is returned. Early exits and returns the error if any of the elements is an Err.

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

where Self: Sized, Self::Item: Send, Self::Err: 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, Ok(None) is returned. Early exits and returns the error if any of the elements is an Err.

fn sum<Out>(self) -> Result<Out, Self::Err>

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

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

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

where Self: Sized, Self::Item: Send, Self::Err: 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, Ok(None) is returned. Early exits and returns the error if an Err element is observed first.