Struct parallel_stream::Map

pub struct Map<T> { /* fields omitted */ }

A parallel stream that maps value of another stream with a function.

Implementations

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

pub fn new<S, F, Fut>(stream: S, f: F) -> Self where
    S: ParallelStream,
    F: FnMut(S::Item) -> Fut + Send + Sync + Copy + 'static,
    Fut: Future<Output = T> + Send, 

Create a new instance of Map.

Trait Implementations

impl<T: Debug> Debug for Map<T>

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

Formats the value using the given formatter.

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

type Item = T

The type of items yielded by this stream.

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

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.

impl<'__pin, T> Unpin for Map<T> where
    __Origin<'__pin, T>: Unpin,