Struct Rev 

pub struct Rev<I> { /* private fields */ }

Reverse adapter with logical-order reversal semantics.

Trait Implementations

impl<I> ParallelIterator for Rev<I>

where I: ParallelIterator, I::Item: Sync + 'static,

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

where C: Consumer<Self::Item, Result = R> + Send + Sync, R: Send,

Why this stays sequential

Reversal needs both each shard’s own stream reversed and the shard order flipped, but Consumer::combine(left, right) fixes the merge order as logically-earlier-first. Expressing this needs an order-reversing consumer wrapper whose base combine is inverted, which is a protocol change rather than an adapter push.

type Item = <I as ParallelIterator>::Item

The type of items yielded by this parallel iterator.

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

Collect all items sequentially without routing through the consumer protocol.

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 seq_iter(self) -> impl Iterator<Item = Self::Item>

Convert the logical item stream into a sequential iterator.

fn seq_try_fold<T, B, F>(self, init: T, fold_fn: F) -> ControlFlow<B, T>

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

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

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 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::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::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::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::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<S> + 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<P> + 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.