Trait ParallelStream 

pub trait ParallelStream:
    Sized
    + Send
    + Sync
    + Unpin
    + 'static {
    type Item: Send;

    // Required methods
    fn poll_next(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Option<Self::Item>>;
    fn limit(self, limit: impl Into<Option<usize>>) -> Self;
    fn get_limit(&self) -> Option<usize>;

    // Provided methods
    fn map<F, T, Fut>(self, f: F) -> Map<T>
       where F: FnMut(Self::Item) -> Fut + Send + Sync + Copy + 'static,
             T: Send + 'static,
             Fut: Future<Output = T> + Send { ... }
    fn next(&mut self) -> NextFuture<'_, Self> { ... }
    fn take(self, n: usize) -> Take<Self>
       where Self: Sized { ... }
    fn for_each<F, Fut>(self, f: F) -> ForEach 
       where F: FnMut(Self::Item) -> Fut + Send + Sync + Copy + 'static,
             Fut: Future<Output = ()> + Send { ... }
    fn collect<'a, B>(self) -> Pin<Box<dyn Future<Output = B> + Send + 'a>>
       where Self: Sized + 'a,
             B: FromParallelStream<Self::Item> { ... }
}

Parallel version of the standard Stream trait.

Required Associated Types

type Item: Send

The type of items yielded by this stream.

Required Methods

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempts to receive the next item from the stream.

fn limit(self, limit: impl Into<Option<usize>>) -> Self

Set a max concurrency limit

fn get_limit(&self) -> Option<usize>

Get the max concurrency limit

Provided Methods

fn map<F, T, Fut>(self, f: F) -> Map<T>

where F: FnMut(Self::Item) -> Fut + Send + Sync + Copy + 'static, T: Send + 'static, Fut: Future<Output = T> + Send,

Applies f to each item of this stream in parallel, producing a new stream with the results.

fn next(&mut self) -> NextFuture<'_, Self>

Applies f to each item of this stream in parallel, producing a new stream with the results.

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

where Self: Sized,

Creates a stream that yields its first n elements.

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

where F: FnMut(Self::Item) -> Fut + Send + Sync + Copy + 'static, Fut: Future<Output = ()> + Send,

Applies f to each item of this stream in parallel.

fn collect<'a, B>(self) -> Pin<Box<dyn Future<Output = B> + Send + 'a>>

where Self: Sized + 'a, B: FromParallelStream<Self::Item>,

Transforms a stream into a collection.

collect() can take anything streamable, and turn it into a relevant collection. This is one of the more powerful methods in the async standard library, used in a variety of contexts.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<S: ParallelStream> ParallelStream for Take<S>

type Item = <S as ParallelStream>::Item

impl<S: Stream + Send + Sync + Unpin + 'static> ParallelStream for FromStream<S>

where S::Item: Send,

type Item = <S as Stream>::Item

impl<T: Send + 'static> ParallelStream for Map<T>

type Item = T

impl<T: Send + Sync + 'static> ParallelStream for IntoParStream<T>

type Item = T