# Struct futures::sync::oneshot::Sender [−] [src]

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

Represents the completion half of a oneshot through which the result of a computation is signaled.

This is created by the `oneshot::channel` function.

## Methods

### `impl<T> Sender<T>`
[src]

#### `pub fn send(self, t: T) -> Result<(), T>`
[src]

Completes this oneshot with a successful result.

This function will consume `self` and indicate to the other end, the `Receiver`, that the value provided is the result of the computation this represents.

If the value is successfully enqueued for the remote end to receive, then `Ok(())` is returned. If the receiving end was deallocated before this function was called, however, then `Err` is returned with the value provided.

#### `pub fn poll_cancel(&mut self) -> Poll<(), ()>`
[src]

Polls this `Sender` half to detect whether the `Receiver` this has paired with has gone away.

This function can be used to learn about when the `Receiver` (consumer) half has gone away and nothing will be able to receive a message sent from `send`.

If `Ready` is returned then it means that the `Receiver` has disappeared and the result this `Sender` would otherwise produce should no longer be produced.

If `NotReady` is returned then the `Receiver` is still alive and may be able to receive a message if sent. The current task, however, is scheduled to receive a notification if the corresponding `Receiver` goes away.

# Panics

Like `Future::poll`, this function will panic if it's not called from within the context of a task. In other words, this should only ever be called from inside another future.

If you're calling this function from a context that does not have a task, then you can use the `is_canceled` API instead.

#### `pub fn is_canceled(&self) -> bool`
[src]

Tests to see whether this `Sender`'s corresponding `Receiver` has gone away.

This function can be used to learn about when the `Receiver` (consumer) half has gone away and nothing will be able to receive a message sent from `send`.

Note that this function is intended to not be used in the context of a future. If you're implementing a future you probably want to call the `poll_cancel` function which will block the current task if the cancellation hasn't happened yet. This can be useful when working on a non-futures related thread, though, which would otherwise panic if `poll_cancel` were called.

## Trait Implementations

### `impl<T: Debug> Debug for Sender<T>`
[src]

#### `fn fmt(&self, __arg_0: &mut Formatter) -> Result`
[src]

Formats the value using the given formatter. Read more

### `impl<T> Drop for Sender<T>`
[src]

#### `fn drop(&mut self)`
[src]

Executes the destructor for this type. Read more

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## 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`)