Struct AsyncMap 

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

An asynchronous iterator adapter that maps each item to a new value using an async function.

AsyncMap is similar to the standard .map() method on iterators, but it supports asynchronous closures by allowing the mapping function to return a Future. This makes it useful for scenarios where each item in an iterator needs to be processed using asynchronous logic.

This struct is created by the .map_async() method on AsyncIterTools.

Type Parameters

• I: The underlying async iterator.
• F: The asynchronous mapping function, which produces a future for each item.

Trait Implementations

impl<B, I, F, Fut> AsyncIterator for AsyncMap<I, F>

where I: AsyncIterator, F: FnMut(I::Item) -> Fut + Send, Fut: Future<Output = B> + Send,

Implements the AsyncIterator trait for AsyncMap, yielding the result of applying the async mapping function f to each item from the underlying iterator iter.

The next_async() method awaits the next item and then applies the mapping function, awaiting its result before yielding it downstream.

type Item = B

The type of the elements being iterated over.

async fn next_async(&mut self) -> Option<Self::Item>

Asynchronously returns the next item in the iterator.

fn async_size_hint(&self) -> (usize, Option<usize>)

Provides a hint about the size of the remaining items.

fn sync_iter(&mut self) -> impl Future<Output = SyncIter<IntoIter<Self::Item>>>

where Self: Sized,

Converts this async iterator into a synchronous SyncIter using async collection.

fn async_collect<B>(self) -> impl Future<Output = B>

where Self: Sized, B: FromIterator<Self::Item>,

Collects all items of the async iterator into a container type.

impl<I, F> Debug for AsyncMap<I, F>

where I: AsyncIterator + Debug,

Provides a Debug implementation for AsyncMap that includes debug output for the underlying iterator. The mapping function f is not shown due to lack of generic support for Debug on closures.

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B, I, F, Fut> Future for AsyncMap<I, F>

where I: AsyncIterator + Unpin, F: FnMut(I::Item) -> Fut + Unpin + Send, Fut: Future<Output = B> + Send,

Allows an AsyncMap to be .awaited directly, returning a synchronous iterator (SyncIter) over the collected results of the async mapping operation. This makes it possible to use .await on AsyncMap to collect all results at once in blocking contexts like block_on.

type Output = SyncIter<IntoIter<B>>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<B, I, F, Fut> PollSyncIter for AsyncMap<I, F>

where I: AsyncIterator + Unpin, F: FnMut(I::Item) -> Fut + Unpin + Send, Fut: Future<Output = B> + Send,

Enables conversion of an AsyncMap into a synchronous SyncIter by polling the async iterator and collecting items into a vector. Implements the PollSyncIter trait, allowing integration with the Future implementation below.

fn poll_sync_iter( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<SyncIter<IntoIter<Self::Item>>>

where Self: Sized + Unpin,