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", so this trait is not object safe.

Implementors

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

where S::Item: Send,

type Item = <S as Stream>::Item

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

type Item = <S as ParallelStream>::Item

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

type Item = T

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

type Item = T