# Struct std::sync::mpsc::Receiver [−] [src]

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

1.0.0

The receiving-half of Rust's channel type. This half can only be owned by one thread

## Methods

### `impl<T> Receiver<T>`

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

Attempts to return a pending value on this receiver without blocking

This method will never block the caller in order to wait for data to become available. Instead, this will always return immediately with a possible option of pending data on the channel.

This is useful for a flavor of "optimistic check" before deciding to block on a receiver.

#### `fn recv(&self) -> Result<T, RecvError>`

Attempts to wait for a value on this receiver, returning an error if the corresponding channel has hung up.

This function will always block the current thread if there is no data available and it's possible for more data to be sent. Once a message is sent to the corresponding `Sender`, then this receiver will wake up and return that message.

If the corresponding `Sender` has disconnected, or it disconnects while this call is blocking, this call will wake up and return `Err` to indicate that no more messages can ever be received on this channel. However, since channels are buffered, messages sent before the disconnect will still be properly received.

# Examples

fn main() { use std::sync::mpsc; use std::thread; let (send, recv) = mpsc::channel(); let handle = thread::spawn(move || { send.send(1u8).unwrap(); }); handle.join().unwrap(); assert_eq!(Ok(1), recv.recv()); }

    use std::sync::mpsc;
    use std::thread;

    let (send, recv) = mpsc::channel();
    let handle = thread::spawn(move || {
        send.send(1u8).unwrap();
    });

    handle.join().unwrap();

    assert_eq!(Ok(1), recv.recv());

Buffering behavior:

fn main() { use std::sync::mpsc; use std::thread; use std::sync::mpsc::RecvError; let (send, recv) = mpsc::channel(); let handle = thread::spawn(move || { send.send(1u8).unwrap(); send.send(2).unwrap(); send.send(3).unwrap(); drop(send); }); // wait for the thread to join so we ensure the sender is dropped handle.join().unwrap(); assert_eq!(Ok(1), recv.recv()); assert_eq!(Ok(2), recv.recv()); assert_eq!(Ok(3), recv.recv()); assert_eq!(Err(RecvError), recv.recv()); }

    use std::sync::mpsc;
    use std::thread;
    use std::sync::mpsc::RecvError;

    let (send, recv) = mpsc::channel();
    let handle = thread::spawn(move || {
        send.send(1u8).unwrap();
        send.send(2).unwrap();
        send.send(3).unwrap();
        drop(send);
    });

    // wait for the thread to join so we ensure the sender is dropped
    handle.join().unwrap();

    assert_eq!(Ok(1), recv.recv());
    assert_eq!(Ok(2), recv.recv());
    assert_eq!(Ok(3), recv.recv());
    assert_eq!(Err(RecvError), recv.recv());

#### `fn iter(&self) -> Iter<T>`

Returns an iterator that will block waiting for messages, but never `panic!`. It will return `None` when the channel has hung up.

## Trait Implementations

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

### `impl<T> !Sync for Receiver<T>`

### `impl<'a, T> IntoIterator for &'a Receiver<T>`1.1.0

#### `type Item = T`

#### `type IntoIter = Iter<'a, T>`

#### `fn into_iter(self) -> Iter<'a, T>`

### `impl<T> IntoIterator for Receiver<T>`1.1.0

#### `type Item = T`

#### `type IntoIter = IntoIter<T>`

#### `fn into_iter(self) -> IntoIter<T>`

### `impl<T> Drop for Receiver<T>`

#### `fn drop(&mut self)`

### `impl<T> Debug for Receiver<T>`1.7.0

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

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)