Trait futures_concurrency::stream::StreamExt

pub trait StreamExt: Stream {
    // Required methods
    fn merge<T, S2>(self, other: S2) -> Merge2<T, Self, S2::IntoStream>
       where Self: Stream<Item = T> + Sized,
             S2: IntoStream<Item = T>;
    fn chain<T, S2>(self, other: S2) -> Chain2<Self, S2::IntoStream>
       where Self: Stream<Item = T> + Sized,
             S2: IntoStream<Item = T>;
    fn zip<T, S2>(self, other: S2) -> Zip2<Self, S2::IntoStream>
       where Self: Stream<Item = T> + Sized,
             S2: IntoStream<Item = T>;

    // Provided methods
    fn co(self) -> FromStream<Self>
       where Self: Sized { ... }
    fn wait_until<D>(self, deadline: D) -> WaitUntil<Self, D::IntoFuture>
       where Self: Sized,
             D: IntoFuture { ... }
}

An extension trait for the Stream trait.

Required Methods

fn merge<T, S2>(self, other: S2) -> Merge2<T, Self, S2::IntoStream>

where Self: Stream<Item = T> + Sized, S2: IntoStream<Item = T>,

Combines two streams into a single stream of all their outputs.

fn chain<T, S2>(self, other: S2) -> Chain2<Self, S2::IntoStream>

where Self: Stream<Item = T> + Sized, S2: IntoStream<Item = T>,

Takes two streams and creates a new stream over all in sequence

fn zip<T, S2>(self, other: S2) -> Zip2<Self, S2::IntoStream>

where Self: Stream<Item = T> + Sized, S2: IntoStream<Item = T>,

‘Zips up’ multiple streams into a single stream of pairs.

Provided Methods

fn co(self) -> FromStream<Self>

where Self: Sized,

Convert into a concurrent stream.

fn wait_until<D>(self, deadline: D) -> WaitUntil<Self, D::IntoFuture>

where Self: Sized, D: IntoFuture,

Delay the yielding of items from the stream until the given deadline.

The underlying stream will not be polled until the deadline has expired. In addition to using a time source as a deadline, any future can be used as a deadline too. When used in combination with a multi-consumer channel, this method can be used to synchronize the start of multiple streams and futures.

Example

use async_io::Timer;
use futures_concurrency::prelude::*;
use futures_lite::{future::block_on, stream};
use futures_lite::prelude::*;
use std::time::{Duration, Instant};

block_on(async {
    let now = Instant::now();
    let duration = Duration::from_millis(100);

    stream::once("meow")
        .wait_until(Timer::after(duration))
        .next()
        .await;

    assert!(now.elapsed() >= duration);
});

Implementors

impl<S1> StreamExt for S1

where S1: Stream,