Struct Map

pub struct Map<CS, F, FutT, T, FutB, B>
where
    CS: ConcurrentStream<Item = T, Future = FutT>,
    F: Fn(T) -> FutB + Clone,
    FutT: Future<Output = T>,
    FutB: Future<Output = B>,
{ /* private fields */ }

Convert items from one type into another

Trait Implementations

impl<CS, F, FutT, T, FutB, B> ConcurrentStream for Map<CS, F, FutT, T, FutB, B>

where CS: ConcurrentStream<Item = T, Future = FutT>, F: Fn(T) -> FutB + Clone, FutT: Future<Output = T>, FutB: Future<Output = B>,

type Future = MapFuture<F, FutT, T, FutB, B>

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

type Item = B

Which item will we be yielding?

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

where C: Consumer<Self::Item, Self::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<NonZeroUsize>

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<NonZeroUsize>) -> 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, F, FutT, T: Debug, FutB, B: Debug> Debug for Map<CS, F, FutT, T, FutB, B>

where CS: ConcurrentStream<Item = T, Future = FutT> + Debug, F: Fn(T) -> FutB + Clone + Debug, FutT: Future<Output = T> + Debug, FutB: Future<Output = B> + Debug,

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

Formats the value using the given formatter.