Struct ParXap 

pub struct ParXap<I, Vo, M1, R = DefaultRunner>
where
    R: ParallelRunner,
    I: ConcurrentIter,
    Vo: TransformableValues<Fallibility = Infallible>,
    M1: Fn(I::Item) -> Vo + Sync,
{ /* private fields */ }

A parallel iterator that xaps inputs.

xap is a generalization of one-to-one map, filter-map and flat-map operations.

Trait Implementations

impl<I, Vo, M1, R> ParIter<R> for ParXap<I, Vo, M1, R>

where R: ParallelRunner, I: ConcurrentIter, Vo: TransformableValues<Fallibility = Infallible>, M1: Fn(I::Item) -> Vo + Sync,

type Item = <Vo as Values>::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>) -> Self

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

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

Sets the iteration order of the parallel computation.

fn with_runner<Q: ParallelRunner>(self) -> impl ParIter<Q, Item = Self::Item>

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 = <Self as ParIter<R>>::Item>

where U: Send + 'static, F: FnMut(usize) -> U,

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, using: U, ) -> impl ParIterUsing<UsingClone<U>, R, Item = <Self as ParIter<R>>::Item>

where U: Clone + Send + '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(Self::Item) -> Out + 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 = Self::Item>

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

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::Item>

where IOut: IntoIterator, 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 ParIter<R, Item = Out>

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

Creates an iterator that both filters and maps.

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

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

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

Collects all the items from an iterator into a collection.

fn reduce<Reduce>(self, reduce: Reduce) -> Option<Self::Item>

where Self::Item: Send, Reduce: Fn(Self::Item, Self::Item) -> Self::Item + Sync,

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

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

where Self::Item: Send,

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

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, Vo, M1, R> Send for ParXap<I, Vo, M1, R>

where R: ParallelRunner, I: ConcurrentIter, Vo: TransformableValues<Fallibility = Infallible>, M1: Fn(I::Item) -> Vo + Sync,

impl<I, Vo, M1, R> Sync for ParXap<I, Vo, M1, R>

where R: ParallelRunner, I: ConcurrentIter, Vo: TransformableValues<Fallibility = Infallible>, M1: Fn(I::Item) -> Vo + Sync,