Struct AsyncParallelAdapter 

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

Adapter to make async iterators work with parallel processing

Trait Implementations

impl<I: AsyncIterator> AsyncIterator for AsyncParallelAdapter<I>

type Item = <I as AsyncIterator>::Item

The type of items yielded by this async iterator

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

Materialize the iterator into its logical item sequence.

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

where Self: Sized, F: Fn(Self::Item) -> Fut + Send + Sync, Fut: Future<Output = R> + Send, R: Send,

Async map operation that transforms each element

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

where Self: Sized, F: Fn(&Self::Item) -> Fut + Send + Sync, Fut: Future<Output = bool> + Send,

Async filter operation

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

where Self: Sized,

Retain at most count items from the logical async stream prefix.

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

where Self: Sized,

Discard count items from the logical async stream prefix.

fn enumerate(self) -> AsyncEnumerate<Self>

where Self: Sized,

Pair each item with its zero-based logical stream position.

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

where Self: Sized, J: AsyncIterator,

Pair items with another async iterator, stopping at the shorter input.

fn for_each<F, Fut>(self, func: F) -> AsyncForEach<Self, F>

where Self: Sized, F: Fn(Self::Item) -> Fut + Send + Sync, Fut: Future<Output = ()> + Send,

Async for_each operation with side effects

fn collect<C>(self) -> AsyncCollect<Self, C>

where Self: Sized, C: Default + Extend<Self::Item> + Send,

Collect into a vector asynchronously

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

where Self: Sized, F: Fn(T, Self::Item) -> Fut + Send + Sync, Fut: Future<Output = T> + Send, T: Send,

Fold operation with async function

fn reduce<F, Fut>(self, reduce_fn: F) -> AsyncReduce<Self, F>

where Self: Sized, F: Fn(Self::Item, Self::Item) -> Fut + Send + Sync, Fut: Future<Output = Self::Item> + Send,

Reduce operation for async iterators

fn into_parallel(self) -> AsyncParallelAdapter<Self>

where Self: Sized,

Convert to parallel iterator for hybrid processing

impl<I: AsyncIterator> AsyncParallelIterator for AsyncParallelAdapter<I>

fn par_map<F, Fut, R>( self, concurrency: usize, map_fn: F, ) -> ParAsyncMap<Self, F>

where Self: Sized, F: Fn(Self::Item) -> Fut + Send + Sync, Fut: Future<Output = R> + Send, R: Send,

Execute async operations in parallel with controlled concurrency

fn par_filter<F, Fut>( self, concurrency: usize, filter_fn: F, ) -> ParAsyncFilter<Self, F>

where Self: Sized, F: Fn(&Self::Item) -> Fut + Send + Sync, Fut: Future<Output = bool> + Send,

Parallel async filter with concurrency control

fn par_for_each<F, Fut>( self, concurrency: usize, func: F, ) -> impl Future<Output = ()> + Send

where Self: Sized, F: Fn(Self::Item) -> Fut + Send + Sync, Fut: Future<Output = ()> + Send,

Execute side effects in parallel with async operations.