Struct Enumerate 

pub struct Enumerate<CS>
where
    CS: ConcurrentStream,
{ /* private fields */ }

Available on crate features nano-alloc and alloc only.

A concurrent iterator that yields the current count and the element during iteration.

This struct is created by the enumerate method on ConcurrentStream. See its documentation for more.

Trait Implementations

impl<CS> ConcurrentStream for Enumerate<CS>

where CS: ConcurrentStream,

type Item = (usize, <CS as ConcurrentStream>::Item)

Which item will we be yielding?

type Future = EnumerateFuture<<CS as ConcurrentStream>::Future, <CS as ConcurrentStream>::Item>

What’s the type of the future containing our items?

async fn drive<C>( self, consumer: C, ) -> <C as Consumer<<Enumerate<CS> as ConcurrentStream>::Item, <Enumerate<CS> as ConcurrentStream>::Future>>::Output

where C: Consumer<<Enumerate<CS> as ConcurrentStream>::Item, <Enumerate<CS> as ConcurrentStream>::Future>,

Internal method used to define the behavior of this concurrent iterator. You should not need to call this directly. This method causes the iterator self to start producing items and to feed them to the consumer consumer one by one.

fn concurrency_limit(&self) -> Option<NonZero<usize>>

How much concurrency should we apply?

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

How many items could we potentially end up returning?

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates a stream which gives the current iteration count as well as the next value.

fn limit(self, limit: Option<NonZero<usize>>) -> Limit<Self>

where Self: Sized,

Obtain a simple pass-through adapter.

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

where Self: Sized,

Creates a stream that yields the first n elements, or fewer if the underlying iterator ends sooner.

fn map<F, FutB, B>( self, f: F, ) -> Map<Self, F, Self::Future, Self::Item, FutB, B>

where Self: Sized, F: Fn(Self::Item) -> FutB + Clone, FutB: Future<Output = B>,

Convert items from one type into another

async fn for_each<F, Fut>(self, f: F)

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

Iterate over each item concurrently

async fn try_for_each<F, Fut, E>(self, f: F) -> Result<(), E>

where Self: Sized, F: Fn(Self::Item) -> Fut + Clone, Fut: Future<Output = Result<(), E>>,

Iterate over each item concurrently, short-circuit on error.

async fn collect<B>(self) -> B

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

Transforms an iterator into a collection.

impl<CS> Debug for Enumerate<CS>

where CS: Debug + ConcurrentStream,

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

Formats the value using the given formatter.