Struct Receiver 

pub struct Receiver<T: Send + Sync + 'static> { /* private fields */ }

Receives the values of the channel, in order.

Created by channel, Sender::subscribe or Receiver::resubscribe; each takes every value sent after it was made.

Implementations

impl<T: Send + Sync + 'static> Receiver<T>

pub fn len(&self) -> usize

How many values were sent that this receiver has yet to take; past the capacity, its next receive reports a lag.

pub fn is_empty(&self) -> bool

Whether this receiver took every value sent.

pub fn resubscribe(&self) -> Self

A new receiver, which takes the values sent from now on.

impl<T: Clone + Send + Sync + 'static> Receiver<T>

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

Takes the next value, if one came, without waiting.

Errors

TryRecvError::Empty when none came since the last one taken; TryRecvError::Lagged once, when the receiver lost values, before it goes on from the oldest one still held; TryRecvError::Closed once every sender is gone and every value was taken.

use nuclei::sync::broadcast::{self, error::TryRecvError};

let (tx, mut rx) = broadcast::channel(2);
for i in 0..3 {
    tx.send(i).unwrap();
}
assert_eq!(rx.try_recv(), Err(TryRecvError::Lagged(1)));
assert_eq!(rx.try_recv(), Ok(1));
assert_eq!(rx.try_recv(), Ok(2));
assert_eq!(rx.try_recv(), Err(TryRecvError::Empty));
drop(tx);
assert_eq!(rx.try_recv(), Err(TryRecvError::Closed));

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

Waits for the next value and takes it.

Errors

RecvError::Lagged once, when the receiver lost values, before it goes on from the oldest one still held; RecvError::Closed once every sender is gone and every value was taken.

Cancel safety

Dropping the future takes nothing: the next receive gets the value.

Cooperative scheduling

On a nuclei shard a receive that completes spends one operation of its task’s budget; with the budget spent it takes nothing and yields to the shard’s other tasks first (see nuclei::task::coop).

pub fn blocking_recv(&mut self) -> Result<T, RecvError>

Receives the next value from a thread that may block.

Like recv, but it parks the calling thread while no value came and the channel is open. On a nuclei shard (inside one of its tasks) it does not park the thread: it runs a nested block_on, so the shard keeps running its other tasks meanwhile. Inside another runtime’s task it blocks that task’s thread.

Errors

As for recv.

Panics

On wasm32, where no other thread can send, when no value came and the channel is open: the call could never end.

use nuclei::sync::broadcast::{self, RecvError};

let (tx, mut rx) = broadcast::channel::<u8>(4);
let receiver = std::thread::spawn(move || {
    assert_eq!(rx.blocking_recv(), Ok(10));
    assert_eq!(rx.blocking_recv(), Err(RecvError::Closed));
});
tx.send(10).unwrap();
drop(tx);
receiver.join().unwrap();

Trait Implementations

impl<T: Send + Sync + 'static> Debug for Receiver<T>

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

Formats the value using the given formatter.

impl<T: Send + Sync + 'static> Drop for Receiver<T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.