Struct async_std::sync::Receiver

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

👎 Deprecated:

new channel api at async_std::channel

This is supported on unstable only.

The receiving side of a channel.

This type receives messages by calling recv. But it also implements the Stream trait, which means it can act as an asynchronous iterator. This struct is created by the channel function. See its documentation for more.

Examples

#![allow(deprecated)]
use std::time::Duration;

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

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

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

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

Implementations

impl<T> Receiver<T>

pub async fn recv<'_>(&'_ self) -> Result<T, RecvError>

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 it. Once all senders have been dropped it will return RecvError.

Examples

#![allow(deprecated)]
use async_std::sync::channel;
use async_std::task;

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

task::spawn(async move {
    s.send(1usize).await;
    s.send(2).await;
    // Then we drop the sender
});

assert_eq!(r.recv().await?, 1);
assert_eq!(r.recv().await?, 2);
assert!(r.recv().await.is_err());

pub fn try_recv(&self) -> Result<T, TryRecvError>

Attempts to receive a message from the channel.

If the channel is empty, this method will return an error.

Examples

#![allow(deprecated)]
use async_std::sync::channel;

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

s.send(1u8).await;

assert!(r.try_recv().is_ok());
assert!(r.try_recv().is_err());

pub fn capacity(&self) -> usize

Returns the channel capacity.

Examples

#![allow(deprecated)]
use async_std::sync::channel;

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

pub fn is_empty(&self) -> bool

Returns true if the channel is empty.

Examples

#![allow(deprecated)]
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

Returns true if the channel is full.

Examples

#![allow(deprecated)]
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

Returns the number of messages in the channel.

Examples

#![allow(deprecated)]
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> Clone for Receiver<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Receiver<T>

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

Formats the value using the given formatter.

impl<T> Drop for Receiver<T>

pub fn drop(&mut self)

Executes the destructor for this type.

impl<T> Stream for Receiver<T>

type Item = T

The type of items yielded by this stream.

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

Attempts to receive the next item from the stream.

pub fn next(&mut self) -> ImplFuture<Option<Self::Item>> where
    Self: Unpin, 

Advances the stream and returns the next value.

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

Creates a stream that yields its first n elements.

pub 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.

pub fn throttle(self, d: Duration) -> Throttle<Self> where
    Self: Sized, 

This is supported on unstable only.

Limit the amount of items yielded per timeslice in a stream.

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

Creates a stream that yields each stepth element.

pub 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.

pub 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.

pub 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.

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

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

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

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

pub fn delay(self, dur: Duration) -> Delay<Self> where
    Self: Sized, 

This is supported on unstable only.

Creates a stream that is delayed before it starts yielding items.

pub 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.

pub 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.

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

Returns the last element of the stream.

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

Creates a stream which ends after the first None.

pub 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.

pub 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.

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

This is supported on unstable only.

Creates an stream that flattens nested structure.

pub 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.

pub 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.

pub 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.

pub 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.

pub fn max(self) -> ImplFuture<Option<Self::Item>> where
    Self: Sized,
    Self::Item: Ord, 

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

pub fn min(self) -> ImplFuture<Option<Self::Item>> where
    Self: Sized,
    Self::Item: Ord, 

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.

pub 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.

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

Returns the nth element of the stream.

pub 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.

pub 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.

pub 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.

pub 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.

pub fn partition<B, F>(self, f: F) -> ImplFuture<(B, B)> where
    Self: Sized,
    F: FnMut(&Self::Item) -> bool,
    B: Default + Extend<Self::Item>, 

This is supported on unstable only.

A combinator that applies a function to every element in a stream creating two collections from it.

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

Call a closure on each element of the stream.

pub 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.

pub fn by_ref(&mut self) -> &mut Self

This is supported on unstable only.

Borrows an stream, rather than consuming it.

pub 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.

pub 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.

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

Creates a combinator that skips the first n elements.

pub 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.

pub 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.

pub 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.

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

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

pub fn unzip<A, B, FromA, FromB>(self) -> ImplFuture<(FromA, FromB)> where
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    Self: Stream<Item = (A, B)> + Sized, 

This is supported on unstable only.

Converts an stream of pairs into a pair of containers.

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

This is supported on unstable only.

Transforms a stream into a collection.

pub 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.

pub 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.

pub 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.

pub 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'.

pub fn count(self) -> ImplFuture<usize> where
    Self: Sized, 

This is supported on unstable only.

Counts the number of elements in the stream.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.