Struct ParAsyncFilter 

pub struct ParAsyncFilter<I, F> { /* private fields */ }

Parallel async filter with concurrency control

Trait Implementations

impl<I, F, Fut> AsyncIterator for ParAsyncFilter<I, F>

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

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