Struct VecParIter 

pub struct VecParIter<T> { /* private fields */ }

Parallel iterator over a vector.

Implementations

impl<T> VecParIter<T>

pub fn new(data: Vec<T>) -> VecParIter<T>

Create a parallel iterator over the given vector.

Trait Implementations

impl<T> IndexedParallelIterator for VecParIter<T>

where T: Send + Sync + 'static,

fn len(&self) -> usize

Return the exact number of logical items in the indexed source.

fn collect_into_vec( self, target: &mut Vec<<VecParIter<T> as ParallelIterator>::Item>, )

Move all items into caller-provided storage.

fn is_empty(&self) -> bool

Return whether the indexed source has no logical items.

fn unzip_into_vecs<A, B>(self, left: &mut Vec<A>, right: &mut Vec<B>)

where Self: ParallelIterator<Item = (A, B)>, A: Send, B: Send,

Split pair items into caller-provided left and right storage.

fn interleave<J>( self, other: J, ) -> Interleave<Self, <J as IntoParallelIterator>::Iter>

where J: IntoParallelIterator<Item = Self::Item>, <J as IntoParallelIterator>::Iter: IndexedParallelIterator<Item = Self::Item>, Self::Item: Sync + 'static,

Alternately yield items from this source and another exact-size source.

fn interleave_shortest<J>( self, other: J, ) -> InterleaveShortest<Self, <J as IntoParallelIterator>::Iter>

where J: IntoParallelIterator<Item = Self::Item>, <J as IntoParallelIterator>::Iter: IndexedParallelIterator<Item = Self::Item>, Self::Item: Sync + 'static,

Alternately yield items until the shorter exact-size source is consumed.

fn step_by(self, step: usize) -> StepBy<Self>

where Self::Item: Sync + 'static,

Yield every stepth item from an exact-size source.

fn by_exponential_blocks(self) -> ExponentialBlocks<Self>

where Self::Item: Sync + 'static,

Convert this exact-size source into value-preserving exponential blocks.

fn by_uniform_blocks(self, block_size: usize) -> UniformBlocks<Self>

where Self::Item: Sync + 'static,

Convert this exact-size source into value-preserving uniform blocks.

impl<T> ParallelIterator for VecParIter<T>

where T: Send + Sync + 'static,

type Item = T

The type of items yielded by this parallel iterator.

fn seq_items(self) -> Vec<<VecParIter<T> as ParallelIterator>::Item>

Collect all items sequentially without routing through the consumer protocol.

fn seq_iter( self, ) -> impl Iterator<Item = <VecParIter<T> as ParallelIterator>::Item>

Convert the logical item stream into a sequential iterator.

fn seq_try_fold<Acc, B, FoldFn>( self, init: Acc, fold_fn: FoldFn, ) -> ControlFlow<B, Acc>

where FoldFn: FnMut(Acc, <VecParIter<T> as ParallelIterator>::Item) -> ControlFlow<B, Acc>,

Fold this iterator’s logical item stream left to right, stopping at the first ControlFlow::Break.

fn drive<C, R>(self, consumer: C) -> R

where C: Consumer<<VecParIter<T> as ParallelIterator>::Item, Result = R> + Send + Sync, R: Send,

Drive the Consumer protocol over this iterator’s items.

fn seq_fold<T, F>(self, init: T, fold_fn: F) -> T

where F: FnMut(T, Self::Item) -> T,

Fold this iterator’s logical item stream left to right.

fn seq_items_window(self, skip: usize, take: Option<usize>) -> Vec<Self::Item>

Collect a logical window from the sequential item stream.

fn seq_items_reversed(self) -> Vec<Self::Item>

Collect items in reverse logical order.

fn seq_items_reversed_prefix(self, count: usize) -> Vec<Self::Item>

Collect a prefix from the reversed logical item stream.

fn map<F, R>(self, map_fn: F) -> Map<Self, F>

where F: Fn(Self::Item) -> R + Send + Sync + Clone, R: Send,

Map operation that transforms each element in parallel.

fn map_with<T, F, R>(self, init: T, map_fn: F) -> MapWith<Self, T, F>

where T: Send + Clone, F: Fn(&mut T, Self::Item) -> R + Send + Sync + Clone, R: Send + Sync + 'static,

Map operation with cloned per-operation state.

fn map_init<Init, T, F, R>( self, init: Init, map_fn: F, ) -> MapInit<Self, Init, F>

where Init: Fn() -> T + Send + Sync + Clone, T: Send, F: Fn(&mut T, Self::Item) -> R + Send + Sync + Clone, R: Send + Sync + 'static,

Map operation with lazily initialized state.

fn update<F>(self, update_fn: F) -> Update<Self, F>

where F: Fn(&mut Self::Item) + Send + Sync + Clone, Self::Item: Sync + 'static,

Mutate each item by reference and yield the mutated item.

fn filter<F>(self, filter_fn: F) -> Filter<Self, F>

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

Filter operation that retains elements matching a predicate.

fn inspect<F>(self, inspect_fn: F) -> Inspect<Self, F>

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

Inspect each element by shared reference without changing the stream.

fn panic_fuse(self) -> PanicFuse<Self>

where Self::Item: Sync,

Preserve value semantics while stopping sibling work after panic where applicable.

fn filter_map<F, R>(self, filter_map_fn: F) -> FilterMap<Self, F>

where F: Fn(Self::Item) -> Option<R> + Send + Sync + Clone, R: Send + Sync + 'static,

Map each element to an optional value and retain present values.

fn while_some<T>(self) -> WhileSome<Self>

where Self: ParallelIterator<Item = Option<T>>, T: Send + Sync + 'static,

Unwrap a prefix of present values from an optional stream.

fn flat_map<F, U>(self, flat_map_fn: F) -> FlatMap<Self, F>

where F: Fn(Self::Item) -> U + Send + Sync + Clone, U: IntoIterator, <U as IntoIterator>::Item: Send + Sync + 'static,

Map each element to an iterator and flatten the resulting sequence.

fn flat_map_iter<F, U>(self, flat_map_fn: F) -> FlatMap<Self, F>

where F: Fn(Self::Item) -> U + Send + Sync + Clone, U: IntoIterator, <U as IntoIterator>::Item: Send + Sync + 'static,

Map each element to a serial iterator and flatten the resulting sequence.

fn flatten(self) -> Flatten<Self>

where Self::Item: IntoIterator, <Self::Item as IntoIterator>::Item: Send + Sync + 'static,

Flatten nested item streams with standard left-to-right semantics.

fn flatten_iter(self) -> Flatten<Self>

where Self::Item: IntoIterator, <Self::Item as IntoIterator>::Item: Send + Sync + 'static,

Flatten nested serial iterators with standard left-to-right semantics.

fn enumerate(self) -> Enumerate<Self>

where Self::Item: Sync + 'static,

Pair each element with its zero-based position in the logical sequence.

fn zip<J>(self, other: J) -> Zip<Self, J>

where J: ParallelIterator, Self::Item: Sync + 'static, <J as ParallelIterator>::Item: Sync + 'static,

Pair elements with another parallel iterator, stopping at the shorter input.

fn zip_eq<J>(self, other: J) -> ZipEq<Self, J>

where J: ParallelIterator, Self::Item: Sync + 'static, <J as ParallelIterator>::Item: Sync + 'static,

Pair elements with another parallel iterator and require equal lengths.

fn take(self, count: usize) -> Take<Self>

where Self::Item: Sync + 'static,

Retain at most count elements from the logical sequence prefix.

fn take_any(self, count: usize) -> Take<Self>

where Self::Item: Sync + 'static,

Retain at most count items from this non-indexed deterministic stream.

fn skip(self, count: usize) -> Skip<Self>

where Self::Item: Sync + 'static,

Discard count elements from the logical sequence prefix.

fn skip_any(self, count: usize) -> Skip<Self>

where Self::Item: Sync + 'static,

Discard count items from this non-indexed deterministic stream.

fn take_any_while<F>(self, predicate: F) -> TakeAnyWhile<Self, F>

where F: Fn(&Self::Item) -> bool + Send + Sync + Clone, Self::Item: Sync + 'static,

Retain this deterministic stream prefix while predicate returns true.

fn skip_any_while<F>(self, predicate: F) -> SkipAnyWhile<Self, F>

where F: Fn(&Self::Item) -> bool + Send + Sync + Clone, Self::Item: Sync + 'static,

Discard this deterministic stream prefix while predicate returns true.

fn chain<J>(self, other: J) -> Chain<Self, J>

where J: ParallelIterator<Item = Self::Item>, Self::Item: Sync + 'static,

Concatenate this iterator with another iterator of the same item type.

fn intersperse(self, separator: Self::Item) -> Intersperse<Self>

where Self::Item: Clone + Sync + 'static,

Insert a cloned separator between adjacent logical items.

fn rev(self) -> Rev<Self>

where Self::Item: Sync + 'static,

Reverse the logical sequence order.

fn chunks(self, chunk_size: usize) -> Chunks<Self>

where Self::Item: Sync + 'static,

Group the logical item stream into non-empty chunks.

fn copied<'data, T>(self) -> Copied<Self>

where Self: ParallelIterator<Item = &'data T>, T: Copy + Send + Sync + 'data + 'static,

Copy referenced items out of a borrowed parallel stream.

fn cloned<'data, T>(self) -> Cloned<Self>

where Self: ParallelIterator<Item = &'data T>, T: Clone + Send + Sync + 'data + 'static,

Clone referenced items out of a borrowed parallel stream.

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

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

Reduce operation that combines all elements.

fn fold<T, F>(self, init: T, fold_fn: F) -> T

where T: Send + Sync + Clone, F: Fn(T, Self::Item) -> T + Send + Sync + Clone, Self::Item: Sync,

Fold operation with an initial value.

fn collect<C>(self) -> C

where C: ParallelExtend<Self::Item> + Default + Send,

Collect into a collection.

fn collect_vec_list(self) -> LinkedList<Vec<Self::Item>>

Collect into a list of owned vector segments.

fn partition<C, F>(self, predicate: F) -> (C, C)

where C: FromIterator<Self::Item> + Send, F: Fn(&Self::Item) -> bool + Send + Sync + Clone, Self::Item: Sync + 'static,

Partition items into two collections while preserving relative order.

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B)

where A: Default + Extend<L> + Send, B: Default + Extend<R> + Send, P: Fn(Self::Item) -> Either<L, R> + Send + Sync + Clone, L: Send, R: Send,

Split mapped Either values into two collections while preserving side-local order.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

where Self: ParallelIterator<Item = (A, B)>, FromA: Default + Extend<A> + Send, FromB: Default + Extend<B> + Send, A: Send, B: Send,

Split a stream of pairs into two collections while preserving order.

fn sequential(self) -> SequentialAdapter<Self>

Convert to a sequential iterator.

fn count(self) -> usize

where Self::Item: Sync,

Count the number of elements.

fn find_first<F>(self, predicate: F) -> Option<Self::Item>

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

Find the first element matching a predicate.

fn find_last<F>(self, predicate: F) -> Option<Self::Item>

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

Find the last element matching a predicate in the logical stream.

fn position_first<F>(self, predicate: F) -> Option<usize>

where F: Fn(Self::Item) -> bool + Send + Sync + Clone,

Find the first logical index matching a predicate.

fn position_any<F>(self, predicate: F) -> Option<usize>

where F: Fn(Self::Item) -> bool + Send + Sync + Clone,

Find any logical index matching a predicate.

fn position_last<F>(self, predicate: F) -> Option<usize>

where F: Fn(Self::Item) -> bool + Send + Sync + Clone,

Find the last logical index matching a predicate.

fn positions<F>(self, predicate: F) -> Positions<Self, F>

where F: Fn(Self::Item) -> bool + Send + Sync + Clone,

Return all logical indices whose items match a predicate.

fn find_map_first<F, R>(self, map_fn: F) -> Option<R>

where F: Fn(Self::Item) -> Option<R> + Send + Sync + Clone, R: Send,

Find and map the first matching element in the logical stream.

fn find_map_any<F, R>(self, map_fn: F) -> Option<R>

where F: Fn(Self::Item) -> Option<R> + Send + Sync + Clone, R: Send,

Find and map any matching element in the logical stream.

fn find_map_last<F, R>(self, map_fn: F) -> Option<R>

where F: Fn(Self::Item) -> Option<R> + Send + Sync + Clone, R: Send,

Find and map the last matching element in the logical stream.

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

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

Test if any element matches a predicate.

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

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

Test if all elements match a predicate.

fn for_each<F>(self, op: F)

where F: Fn(Self::Item) + Send + Sync + Clone,

Apply a function to each element.

fn for_each_with<T, F>(self, init: T, op: F)

where T: Send + Clone, F: Fn(&mut T, Self::Item) + Send + Sync + Clone,

Apply a function to each element with cloned per-operation state.

fn for_each_init<Init, T, F>(self, init: Init, op: F)

where Init: Fn() -> T + Send + Sync + Clone, T: Send, F: Fn(&mut T, Self::Item) + Send + Sync + Clone,

Apply a function to each element with lazily initialized state.

fn try_for_each<F, E>(self, op: F) -> Result<(), E>

where F: Fn(Self::Item) -> Result<(), E> + Send + Sync + Clone, E: Send,

Apply a fallible function to each element and stop on the first error.

fn try_for_each_with<T, F, E>(self, init: T, op: F) -> Result<(), E>

where T: Send + Clone, F: Fn(&mut T, Self::Item) -> Result<(), E> + Send + Sync + Clone, E: Send,

Apply a fallible function to each element with cloned per-operation state.

fn try_for_each_init<Init, T, F, E>(self, init: Init, op: F) -> Result<(), E>

where Init: Fn() -> T + Send + Sync + Clone, T: Send, F: Fn(&mut T, Self::Item) -> Result<(), E> + Send + Sync + Clone, E: Send,

Apply a fallible function to each element with lazily initialized state.

fn reduce_with<F>(self, reduce_fn: F) -> Option<Self::Item>

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

Reduce with an associative operation.

fn try_reduce<Identity, F, T, E>( self, identity: Identity, reduce_fn: F, ) -> Result<T, E>

where Self::Item: Into<Result<T, E>>, Identity: Fn() -> T + Send + Sync + Clone, F: Fn(T, T) -> Result<T, E> + Send + Sync + Clone, T: Send, E: Send,

Reduce a fallible item stream with an identity and associative operation.

fn try_reduce_with<F>(self, reduce_fn: F) -> Option<Self::Item>

where Self::Item: TryStreamItem, F: Fn(<Self::Item as TryStreamItem>::Output, <Self::Item as TryStreamItem>::Output) -> Self::Item + Send + Sync + Clone,

Reduce a fallible item stream without an identity value.

fn sum<S>(self) -> S

where S: Sum<Self::Item> + Send,

Sum the complete logical stream through one standard Iterator::sum invocation.

fn sum_reassociated<S>(self) -> S

where S: Sum<Self::Item> + Sum + Send,

Sum independently produced item fragments and merge their outputs.

fn product<P>(self) -> P

where P: Product<Self::Item> + Send,

Multiply the complete logical stream through one standard Iterator::product invocation.

fn product_reassociated<P>(self) -> P

where P: Product<Self::Item> + Product + Send,

Multiply independently produced item fragments and merge their outputs.

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

where Self::Item: Ord,

Return the minimum item in the logical stream.

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

where Self::Item: Ord,

Return the maximum item in the logical stream.

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

where F: Fn(&Self::Item, &Self::Item) -> Ordering + Send + Sync + Clone,

Return the minimum item according to a comparator.

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

where F: Fn(&Self::Item, &Self::Item) -> Ordering + Send + Sync + Clone,

Return the maximum item according to a comparator.

fn min_by_key<K, F>(self, key_fn: F) -> Option<Self::Item>

where K: Ord, F: Fn(&Self::Item) -> K + Send + Sync + Clone,

Return the minimum item according to an ordered key.

fn max_by_key<K, F>(self, key_fn: F) -> Option<Self::Item>

where K: Ord, F: Fn(&Self::Item) -> K + Send + Sync + Clone,

Return the maximum item according to an ordered key.

fn find_any<F>(self, predicate: F) -> Option<Self::Item>

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

Find any element matching a predicate.