Struct FromStream 

pub struct FromStream<S>
where
    S: Stream,
{ /* private fields */ }

Available on crate features nano-alloc and alloc only.

A concurrent for each implementation from a Stream

Trait Implementations

impl<S> ConcurrentStream for FromStream<S>

where S: Stream,

type Item = <S as Stream>::Item

Which item will we be yielding?

type Future = Ready<<FromStream<S> as ConcurrentStream>::Item>

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

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

where C: Consumer<<FromStream<S> as ConcurrentStream>::Item, <FromStream<S> 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<S> Debug for FromStream<S>

where S: Debug + Stream,

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

Formats the value using the given formatter.

impl<'pin, S> Unpin for FromStream<S>

where S: Stream, <PinnedFieldsOfHelperStruct<__FromStream<'pin, S>> as PinnedFieldsOfHelperTrait>::Actual: Unpin,