Struct Receiver 

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

🔬This is a nightly-only experimental API. (oneshot_channel #143674)

The receiving half of a oneshot channel.

Examples

#![feature(oneshot_channel)]
use std::sync::oneshot;
use std::thread;
use std::time::Duration;

let (sender, receiver) = oneshot::channel();

thread::spawn(move || {
    thread::sleep(Duration::from_millis(100));
    sender.send("Hello after delay!").unwrap();
});

println!("Waiting for message...");
println!("{}", receiver.recv().unwrap());

Receiver cannot be sent between threads if it is receiving non-Send types.

let (sender, receiver) = oneshot::channel();

struct NotSend(*mut ());
sender.send(NotSend(ptr::null_mut()));

thread::spawn(move || {
    let reply = receiver.try_recv().unwrap();
});

Implementations

impl<T> Receiver<T>

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

🔬This is a nightly-only experimental API. (oneshot_channel #143674)

Receives the value from the sending end, blocking the calling thread until it gets it.

Can only fail if the corresponding Sender<T> has been dropped.

Examples

#![feature(oneshot_channel)]
use std::sync::oneshot;
use std::thread;
use std::time::Duration;

let (tx, rx) = oneshot::channel();

thread::spawn(move || {
    thread::sleep(Duration::from_millis(500));
    tx.send("Done!").unwrap();
});

// This will block until the message arrives.
println!("{}", rx.recv().unwrap());

pub fn is_ready(&self) -> Result<bool, RecvError>

🔬This is a nightly-only experimental API. (oneshot_channel #143674)

Returns Ok(true) if the sender has sent a value over the channel.

Returns Ok(false) if no value has been sent, but the corresponding Sender<T> still exists (has not been dropped yet).

Returns a RecvError if the corresponding Sender<T> has been dropped before a value has been sent.

If this method returns Ok(true), then any of the recv methods are guaranteed to return the value successfully without blocking.

Warnings

A return value of Ok(false) does not guarantee that a later receive operation will block. The sender may send a value or be dropped immediately after this method returns.

Polling this method in a loop just to wait for a value wastes CPU time. Use recv or recv_timeout instead.

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

🔬This is a nightly-only experimental API. (oneshot_channel #143674)

Attempts to return a pending value on this receiver without blocking.

To check whether a value is available without consuming the receiver, use is_ready.

Examples

#![feature(oneshot_channel)]
use std::sync::oneshot;
use std::thread;
use std::time::Duration;

let (sender, mut receiver) = oneshot::channel();

thread::spawn(move || {
    thread::sleep(Duration::from_millis(100));
    sender.send(42).unwrap();
});

// Keep trying until we get the message, doing other work in the process.
loop {
    match receiver.try_recv() {
        Ok(value) => {
            assert_eq!(value, 42);
            break;
        }
        Err(oneshot::TryRecvError::Empty(rx)) => {
            // Retake ownership of the receiver.
            receiver = rx;
            do_other_work();
        }
        Err(oneshot::TryRecvError::Disconnected) => panic!("Sender disconnected"),
    }
}

pub fn recv_timeout(self, timeout: Duration) -> Result<T, RecvTimeoutError<T>>

🔬This is a nightly-only experimental API. (oneshot_channel #143674)

Attempts to wait for a value on this receiver, returning an error if the corresponding Sender half of this channel has been dropped, or if it waits more than timeout.

Examples

#![feature(oneshot_channel)]
use std::sync::oneshot;
use std::thread;
use std::time::Duration;

let (sender, receiver) = oneshot::channel();

thread::spawn(move || {
    thread::sleep(Duration::from_millis(500));
    sender.send("Success!").unwrap();
});

// Wait up to 1 second for the message
match receiver.recv_timeout(Duration::from_secs(1)) {
    Ok(msg) => println!("Received: {}", msg),
    Err(oneshot::RecvTimeoutError::Timeout(_)) => println!("Timed out!"),
    Err(oneshot::RecvTimeoutError::Disconnected) => println!("Sender dropped!"),
}

pub fn recv_deadline(self, deadline: Instant) -> Result<T, RecvTimeoutError<T>>

🔬This is a nightly-only experimental API. (oneshot_channel #143674)

Attempts to wait for a value on this receiver, returning an error if the corresponding Sender half of this channel has been dropped, or if deadline is reached.

Examples

#![feature(oneshot_channel)]
use std::sync::oneshot;
use std::thread;
use std::time::{Duration, Instant};

let (sender, receiver) = oneshot::channel();

thread::spawn(move || {
    thread::sleep(Duration::from_millis(100));
    sender.send("Just in time!").unwrap();
});

let deadline = Instant::now() + Duration::from_millis(500);
match receiver.recv_deadline(deadline) {
    Ok(msg) => println!("Received: {}", msg),
    Err(oneshot::RecvTimeoutError::Timeout(_)) => println!("Missed deadline!"),
    Err(oneshot::RecvTimeoutError::Disconnected) => println!("Sender dropped!"),
}

Trait Implementations

impl<T> Debug for Receiver<T>

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

Formats the value using the given formatter.

impl<T> Sync for Receiver<T>