Struct async_std::sync::Receiver

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

This is supported on unstable only.

The receiving side of a channel.

This type implements the Stream trait, which means it can act as an asynchronous iterator.

Examples

use std::time::Duration;

use async_std::sync::channel;
use async_std::task;

let (s, r) = channel(100);

task::spawn(async move {
    s.send(1).await;
    task::sleep(Duration::from_secs(1)).await;
    s.send(2).await;
});

assert_eq!(r.recv().await, Some(1)); // Received immediately.
assert_eq!(r.recv().await, Some(2)); // Received after 1 second.

Methods

impl<T> Receiver<T>

pub async fn recv<'_>(&'_ self) -> Option<T>

This is supported on unstable only.

Receives a message from the channel.

If the channel is empty and still has senders, this method will wait until a message is sent into the channel or until all senders get dropped.

Examples

use async_std::sync::channel;
use async_std::task;

let (s, r) = channel(1);

task::spawn(async move {
    s.send(1).await;
    s.send(2).await;
});

assert_eq!(r.recv().await, Some(1));
assert_eq!(r.recv().await, Some(2));
assert_eq!(r.recv().await, None);

pub fn capacity(&self) -> usize

This is supported on unstable only.

Returns the channel capacity.

Examples

use async_std::sync::channel;

let (_, r) = channel::<i32>(5);
assert_eq!(r.capacity(), 5);

pub fn is_empty(&self) -> bool

This is supported on unstable only.

Returns true if the channel is empty.

Examples

use async_std::sync::channel;

let (s, r) = channel(1);

assert!(r.is_empty());
s.send(0).await;
assert!(!r.is_empty());

pub fn is_full(&self) -> bool

This is supported on unstable only.

Returns true if the channel is full.

Examples

use async_std::sync::channel;

let (s, r) = channel(1);

assert!(!r.is_full());
s.send(0).await;
assert!(r.is_full());

pub fn len(&self) -> usize

This is supported on unstable only.

Returns the number of messages in the channel.

Examples

use async_std::sync::channel;

let (s, r) = channel(2);
assert_eq!(r.len(), 0);

s.send(1).await;
s.send(2).await;
assert_eq!(r.len(), 2);

Trait Implementations

impl<T> Stream for Receiver<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 next(&mut self) -> ImplFuture<Option<Self::Item>> where
    Self: Unpin, 

Advances the stream and returns the next value.

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

Creates a stream that yields its first n elements.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool, 

Creates a stream that yields elements based on a predicate.

fn step_by(self, step: usize) -> StepBy<Self> where
    Self: Sized, 

Creates a stream that yields each stepth element.

fn chain<U>(self, other: U) -> Chain<Self, U> where
    Self: Sized,
    U: Stream<Item = Self::Item> + Sized, 

Takes two streams and creates a new stream over both in sequence.

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: Sized + Stream<Item = &'a T>,
    T: Clone + 'a, 

Creates an stream which copies all of its elements.

fn copied<'a, T>(self) -> Copied<Self> where
    Self: Sized + Stream<Item = &'a T>,
    T: Copy + 'a, 

Creates an stream which copies all of its elements.

fn cycle(self) -> Cycle<Self> where
    Self: Clone + Sized, 

Creates a stream that yields the provided values infinitely and in order.

fn enumerate(self) -> Enumerate<Self> where
    Self: Sized, 

Creates a stream that gives the current element's count as well as the next value.

fn map<B, F>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Item) -> B, 

Takes a closure and creates a stream that calls that closure on every element of this stream.

fn inspect<F>(self, f: F) -> Inspect<Self, F> where
    Self: Sized,
    F: FnMut(&Self::Item), 

A combinator that does something with each element in the stream, passing the value on.

fn last(self) -> ImplFuture<Option<Self::Item>> where
    Self: Sized, 

Returns the last element of the stream.

fn fuse(self) -> Fuse<Self> where
    Self: Sized, 

Creates a stream which ends after the first None.

fn filter<P>(self, predicate: P) -> Filter<Self, P> where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool, 

Creates a stream that uses a predicate to determine if an element should be yielded.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
    Self: Sized,
    U: IntoStream,
    F: FnMut(Self::Item) -> U, 

This is supported on unstable only.

Creates an stream that works like map, but flattens nested structure.

fn flatten(self) -> Flatten<Self> where
    Self: Sized,
    Self::Item: IntoStream, 

This is supported on unstable only.

Creates an stream that flattens nested structure.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Item) -> Option<B>, 

Both filters and maps a stream.

fn min_by_key<B, F>(self, key_by: F) -> ImplFuture<Option<Self::Item>> where
    Self: Sized,
    B: Ord,
    F: FnMut(&Self::Item) -> B, 

Returns the element that gives the minimum value with respect to the specified key function. If several elements are equally minimum, the first element is returned. If the stream is empty, None is returned.

fn max_by_key<B, F>(self, key_by: F) -> ImplFuture<Option<Self::Item>> where
    Self: Sized,
    B: Ord,
    F: FnMut(&Self::Item) -> B, 

Returns the element that gives the maximum value with respect to the specified key function. If several elements are equally maximum, the first element is returned. If the stream is empty, None is returned.

fn min_by<F>(self, compare: F) -> ImplFuture<Option<Self::Item>> where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering, 

Returns the element that gives the minimum value with respect to the specified comparison function. If several elements are equally minimum, the first element is returned. If the stream is empty, None is returned.

fn min<F>(self) -> ImplFuture<Option<Self::Item>> where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering, 

Returns the element that gives the minimum value. If several elements are equally minimum, the first element is returned. If the stream is empty, None is returned.

fn max_by<F>(self, compare: F) -> ImplFuture<Option<Self::Item>> where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering, 

Returns the element that gives the maximum value with respect to the specified comparison function. If several elements are equally maximum, the first element is returned. If the stream is empty, None is returned.

fn nth(&mut self, n: usize) -> ImplFuture<Option<Self::Item>> where
    Self: Unpin + Sized, 

Returns the nth element of the stream.

fn all<F>(&mut self, f: F) -> ImplFuture<bool> where
    Self: Unpin + Sized,
    F: FnMut(Self::Item) -> bool, 

Tests if every element of the stream matches a predicate.

fn find<P>(&mut self, p: P) -> ImplFuture<Option<Self::Item>> where
    Self: Unpin + Sized,
    P: FnMut(&Self::Item) -> bool, 

Searches for an element in a stream that satisfies a predicate.

fn find_map<F, B>(&mut self, f: F) -> ImplFuture<Option<B>> where
    Self: Unpin + Sized,
    F: FnMut(Self::Item) -> Option<B>, 

Applies function to the elements of stream and returns the first non-none result.

fn fold<B, F>(self, init: B, f: F) -> ImplFuture<B> where
    Self: Sized,
    F: FnMut(B, Self::Item) -> B, 

A combinator that applies a function to every element in a stream producing a single, final value.

fn for_each<F>(self, f: F) -> ImplFuture<()> where
    Self: Sized,
    F: FnMut(Self::Item), 

Call a closure on each element of the stream.

fn any<F>(&mut self, f: F) -> ImplFuture<bool> where
    Self: Unpin + Sized,
    F: FnMut(Self::Item) -> bool, 

Tests if any element of the stream matches a predicate.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
    Self: Sized,
    F: FnMut(&mut St, Self::Item) -> Option<B>, 

A stream adaptor similar to [fold] that holds internal state and produces a new stream.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool, 

Combinator that skips elements based on a predicate.

fn skip(self, n: usize) -> Skip<Self> where
    Self: Sized, 

Creates a combinator that skips the first n elements.

fn timeout(self, dur: Duration) -> Timeout<Self> where
    Self: Stream + Sized, 

This is supported on unstable only.

Await a stream or times out after a duration of time.

fn try_fold<B, F, T, E>(&mut self, init: T, f: F) -> ImplFuture<Result<T, E>> where
    Self: Unpin + Sized,
    F: FnMut(B, Self::Item) -> Result<T, E>, 

A combinator that applies a function as long as it returns successfully, producing a single, final value. Immediately returns the error when the function returns unsuccessfully.

fn try_for_each<F, E>(&mut self, f: F) -> ImplFuture<E> where
    Self: Unpin + Sized,
    F: FnMut(Self::Item) -> Result<(), E>, 

Applies a falliable function to each element in a stream, stopping at first error and returning it.

fn zip<U>(self, other: U) -> Zip<Self, U> where
    Self: Sized,
    U: Stream, 

'Zips up' two streams into a single stream of pairs.

fn collect<'a, B>(self) -> ImplFuture<B> where
    Self: Sized + 'a,
    B: FromStream<Self::Item>, 

This is supported on unstable only.

Transforms a stream into a collection.

fn merge<U>(self, other: U) -> Merge<Self, U> where
    Self: Sized,
    U: Stream<Item = Self::Item> + Sized, 

This is supported on unstable only.

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

fn partial_cmp<S>(self, other: S) -> ImplFuture<Option<Ordering>> where
    Self: Sized + Stream,
    S: Stream,
    Self::Item: PartialOrd<S::Item>, 

Lexicographically compares the elements of this Stream with those of another.

fn position<P>(&mut self, predicate: P) -> ImplFuture<Option<usize>> where
    Self: Unpin + Sized,
    P: FnMut(Self::Item) -> bool, 

Searches for an element in a Stream that satisfies a predicate, returning its index.

fn cmp<S>(self, other: S) -> ImplFuture<Ordering> where
    Self: Sized + Stream,
    S: Stream,
    Self::Item: Ord, 

Lexicographically compares the elements of this Stream with those of another using 'Ord'.

fn ne<S>(self, other: S) -> ImplFuture<bool> where
    Self: Sized,
    S: Sized + Stream,
    Self::Item: PartialEq<S::Item>, 

Determines if the elements of this Stream are lexicographically not equal to those of another.

fn ge<S>(self, other: S) -> ImplFuture<bool> where
    Self: Sized + Stream,
    S: Stream,
    Self::Item: PartialOrd<S::Item>, 

Determines if the elements of this Stream are lexicographically greater than or equal to those of another.

fn eq<S>(self, other: S) -> ImplFuture<bool> where
    Self: Sized + Stream,
    S: Sized + Stream,
    Self::Item: PartialEq<S::Item>, 

Determines if the elements of this Stream are lexicographically equal to those of another.

fn gt<S>(self, other: S) -> ImplFuture<bool> where
    Self: Sized + Stream,
    S: Stream,
    Self::Item: PartialOrd<S::Item>, 

Determines if the elements of this Stream are lexicographically greater than those of another.

fn le<S>(self, other: S) -> ImplFuture<bool> where
    Self: Sized + Stream,
    S: Stream,
    Self::Item: PartialOrd<S::Item>, 

Determines if the elements of this Stream are lexicographically less or equal to those of another.

fn lt<S>(self, other: S) -> ImplFuture<bool> where
    Self: Sized + Stream,
    S: Stream,
    Self::Item: PartialOrd<S::Item>, 

Determines if the elements of this Stream are lexicographically less than those of another.

fn sum<'a, S>(self) -> ImplFuture<S> where
    Self: Sized + Stream<Item = S> + 'a,
    S: Sum<Self::Item>, 

This is supported on unstable only.

Sums the elements of a stream.

fn product<'a, P>(self) -> ImplFuture<P> where
    Self: Sized + Stream<Item = P> + 'a,
    P: Product, 

This is supported on unstable only.

Multiplies all elements of the stream.

impl<T> Drop for Receiver<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Clone for Receiver<T>

fn clone(&self) -> Receiver<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Receiver<T>

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

Formats the value using the given formatter.