Enum GenericIterator 

pub enum GenericIterator<T, S, R, O>
where
    T: Send + Sync,
    S: Iterator<Item = T>,
    R: ParallelIterator<Item = T>,
    O: ParIter<Item = T>,
{
    Sequential(S),
    Rayon(R),
    Orx(O),
}

An iterator that generalizes over:

• sequential iterators,
• rayon’s parallel iterators, and
• orx-parallel’s parallel iterators.

This is particularly useful for enabling a convenient way to run experiments using these different computation approaches.

Variants

Sequential(S)

Sequential, or regular, iterator.

Rayon(R)

rayon’s parallel iterator.

Orx(O)

orx-parallel’s parallel iterator.

Implementations

impl<T, S, R, O> GenericIterator<T, S, R, O>

where T: Send + Sync, S: Iterator<Item = T>, R: ParallelIterator<Item = T>, O: ParIter<Item = T>,

pub fn collect_vec(self) -> Vec<T>

Collects the elements of the iterator into a vector.

See collect for details of the general collect method.

impl<T, S, R, O> GenericIterator<T, S, R, O>

where T: Send + Sync, S: Iterator<Item = T>, R: ParallelIterator<Item = T>, O: ParIter<Item = T>,

pub fn find<Predicate>(self, predicate: Predicate) -> Option<T>

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

Find computation for the generic iterator.

See find for details.

pub fn find_any<Predicate>(self, predicate: Predicate) -> Option<T>

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

Find-any computation for the generic iterator.

See first for details.

impl<T, S> GenericIterator<T, S, Empty<T>, ParEmpty<T>>

where T: Send + Sync, S: Iterator<Item = T>,

pub fn sequential(iter: S) -> Self

Creates the generic iterator from sequential iterator variant.

impl<T, R> GenericIterator<T, Empty<T>, R, ParEmpty<T>>

where T: Send + Sync, R: ParallelIterator<Item = T>,

pub fn rayon(iter: R) -> Self

Creates the generic iterator from rayon iterator variant.

impl<T, O> GenericIterator<T, Empty<T>, Empty<T>, O>

where T: Send + Sync, O: ParIter<Item = T>,

pub fn orx(iter: O) -> Self

Creates the generic iterator from orx-parallel iterator variant.

impl<T, S, R, O> GenericIterator<T, S, R, O>

where T: Send + Sync, S: Iterator<Item = T>, R: ParallelIterator<Item = T>, O: ParIter<Item = T>,

pub fn reduce<Reduce>(self, reduce: Reduce) -> Option<T>

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

Reduction for the generic iterator.

See reduce for details.

pub fn count(self) -> usize

Count reduction for the generic iterator.

See count for details.

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

where Operation: Fn(T) + Sync + Send,

For-each iteration for the generic iterator.

See for_each for details.

pub fn max(self) -> Option<T>

where T: Ord,

Max reduction for the generic iterator.

See max for details.

pub fn max_by<Compare>(self, compare: Compare) -> Option<T>

where Compare: Fn(&T, &T) -> Ordering + Sync + Send,

Max-by reduction for the generic iterator.

See max_by for details.

pub fn max_by_key<Key, GetKey>(self, key: GetKey) -> Option<T>

where Key: Ord + Send, GetKey: Fn(&T) -> Key + Sync + Send,

Max-by-key reduction for the generic iterator.

See max_by_key for details.

pub fn min(self) -> Option<T>

where T: Ord,

Min reduction for the generic iterator.

See min for details.

pub fn min_by<Compare>(self, compare: Compare) -> Option<T>

where Compare: Fn(&T, &T) -> Ordering + Sync + Send,

Min-by reduction for the generic iterator.

See min_by for details.

pub fn min_by_key<Key, GetKey>(self, key: GetKey) -> Option<T>

where Key: Ord + Send, GetKey: Fn(&T) -> Key + Sync + Send,

Min-by-key reduction for the generic iterator.

See min_by_key for details.

pub fn sum(self) -> T

where T: Sum<T> + Sum<T>,

Sum reduction for the generic iterator.

See sum for details.

impl<T, S, R, O> GenericIterator<T, S, R, O>

where T: Send + Sync, S: Iterator<Item = T>, R: ParallelIterator<Item = T>, O: ParIter<Item = T>,

pub fn map<Out, Map>( self, map: Map, ) -> GenericIterator<Out, impl Iterator<Item = Out>, impl ParallelIterator<Item = Out>, impl ParIter<Item = Out>>

where Out: Send + Sync, Map: Fn(T) -> Out + Send + Sync + Clone,

Map transformation for the generic iterator.

See map for details.

pub fn filter<Filter>( self, filter: Filter, ) -> GenericIterator<T, impl Iterator<Item = T>, impl ParallelIterator<Item = T>, impl ParIter<Item = T>>

where Filter: Fn(&T) -> bool + Send + Sync + Clone,

Filter transformation for the generic iterator.

See filter for details.

pub fn flat_map<IOut, FlatMap>( self, flat_map: FlatMap, ) -> GenericIterator<<IOut as IntoIterator>::Item, impl Iterator<Item = <IOut as IntoIterator>::Item>, impl ParallelIterator<Item = <IOut as IntoIterator>::Item>, impl ParIter<Item = <IOut as IntoIterator>::Item>>

where IOut: IntoIterator + Send + Sync + IntoParallelIterator<Item = <IOut as IntoIterator>::Item>, <IOut as IntoIterator>::IntoIter: Send + Sync, <IOut as IntoIterator>::Item: Send + Sync, FlatMap: Fn(T) -> IOut + Send + Sync + Clone,

Flat-map transformation for the generic iterator.

See flat_map for details.

pub fn filter_map<Out, FilterMap>( self, filter_map: FilterMap, ) -> GenericIterator<Out, impl Iterator<Item = Out>, impl ParallelIterator<Item = Out>, impl ParIter<Item = Out>>

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

Filter-map transformation for the generic iterator.

See filter_map for details.

pub fn inspect<Operation>( self, operation: Operation, ) -> GenericIterator<T, impl Iterator<Item = T>, impl ParallelIterator<Item = T>, impl ParIter<Item = T>>

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

Inspect transformation for the generic iterator.

See inspect for details.

pub fn flatten( self, ) -> GenericIterator<<T as IntoIterator>::Item, impl Iterator<Item = <T as IntoIterator>::Item>, impl ParallelIterator<Item = <T as IntoIterator>::Item>, impl ParIter<Item = <T as IntoIterator>::Item>>

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

Flatten transformation for the generic iterator.

See flatten for details.

impl<'a, T, S, R, O> GenericIterator<&'a T, S, R, O>

where &'a T: Send + Sync, S: Iterator<Item = &'a T>, R: ParallelIterator<Item = &'a T>, O: ParIter<Item = &'a T>,

pub fn copied( self, ) -> GenericIterator<T, impl Iterator<Item = T> + use<'a, T, S, R, O>, impl ParallelIterator<Item = T> + use<'a, T, S, R, O>, impl ParIter<Item = T> + use<'a, T, S, R, O>>

where T: Copy + Send + Sync + 'a,

Copied transformation for the generic iterator.

See copied for details.

pub fn cloned( self, ) -> GenericIterator<T, impl Iterator<Item = T> + use<'a, T, S, R, O>, impl ParallelIterator<Item = T> + use<'a, T, S, R, O>, impl ParIter<Item = T> + use<'a, T, S, R, O>>

where T: Clone + Send + Sync + 'a,

Cloned transformation for the generic iterator.

See cloned for details.