Struct piper::Receiver

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

The receiving side of a channel.

This struct is created by the chan function. See its documentation for more.

Receivers can be cloned and implement Stream. Note if a message is sent into a channel and there are multiple receivers, only one of them will receive the message.

Examples

use smol::{Task, Timer};
use std::time::Duration;

let (s, r) = piper::chan(100);

let t = Task::spawn((async move {
    s.send(1).await;
    Timer::after(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.

Implementations

impl<T> Receiver<T>

pub fn try_recv(&self) -> Option<T>

TODO

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

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

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

Returns true if the channel is empty.

If the channel's capacity is zero, it is always 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

Returns true if the channel is full.

If the channel's capacity is zero, it is always 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

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

impl<T> Drop for Receiver<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Send> Send for Receiver<T>

impl<T> Stream for Receiver<T>

type Item = T

Values yielded by the stream.

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

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<T: Send> Sync for Receiver<T>

impl<T> Unpin for Receiver<T>