Struct futures_concurrency::concurrent_stream::Take

pub struct Take<CS: ConcurrentStream> { /* private fields */ }

A concurrent iterator that only iterates over the first n iterations of iter.

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

Trait Implementations

impl<CS: ConcurrentStream> ConcurrentStream for Take<CS>

type Item = <CS as ConcurrentStream>::Item

Which item will we be yielding?

type Future = <CS as ConcurrentStream>::Future

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

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: Debug + ConcurrentStream> Debug for Take<CS>

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

Formats the value using the given formatter.