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

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

The transmission end of a channel which is used to send values.

This is created by the `channel` method.

## Methods

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

#### `pub fn try_send(&mut self, msg: T) -> Result<(), TrySendError<T>>`
[src]

Attempts to send a message on this `Sender<T>` without blocking.

This function, unlike `start_send`, is safe to call whether it's being called on a task or not. Note that this function, however, will not attempt to block the current task if the message cannot be sent.

It is not recommended to call this function from inside of a future, only from an external thread where you've otherwise arranged to be notified when the channel is no longer full.

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

Polls the channel to determine if there is guaranteed to be capacity to send at least one item without waiting.

Returns `Ok(Async::Ready(_))` if there is sufficient capacity, or returns `Ok(Async::NotReady)` if the channel is not guaranteed to have capacity. Returns `Err(SendError(_))` if the receiver has been dropped.

# Panics

This method will panic if called from outside the context of a task or future.

## 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> Sink for Sender<T>`
[src]

#### `type SinkItem = T`

The type of value that the sink accepts.

#### `type SinkError = SendError<T>`

The type of value produced by the sink when an error occurs.

#### `fn start_send(&mut self, msg: T) -> StartSend<T, SendError<T>>`
[src]

Begin the process of sending a value to the sink. Read more

#### `fn poll_complete(&mut self) -> Poll<(), SendError<T>>`
[src]

Flush all output from this sink, if necessary. Read more

#### `fn close(&mut self) -> Poll<(), SendError<T>>`
[src]

A method to indicate that no more values will ever be pushed into this sink. Read more

#### `fn wait(self) -> Wait<Self> where
Self: Sized,`
[src]

Creates a new object which will produce a synchronous sink. Read more

#### `fn with<U, F, Fut>(self, f: F) -> With<Self, U, F, Fut> where
F: FnMut(U) -> Fut,
Fut: IntoFuture<Item = Self::SinkItem>,
Fut::Error: From<Self::SinkError>,
Self: Sized,`
[src]

Composes a function in front of the sink. Read more

#### `fn with_flat_map<U, F, St>(self, f: F) -> WithFlatMap<Self, U, F, St> where
F: FnMut(U) -> St,
St: Stream<Item = Self::SinkItem, Error = Self::SinkError>,
Self: Sized,`
[src]

Composes a function in front of the sink. Read more

#### `fn sink_map_err<F, E>(self, f: F) -> SinkMapErr<Self, F> where
F: FnOnce(Self::SinkError) -> E,
Self: Sized,`
[src]

Transforms the error returned by the sink.

#### `fn sink_from_err<E: From<Self::SinkError>>(self) -> SinkFromErr<Self, E> where
Self: Sized,`
[src]

Map this sink's error to any error implementing `From` for this sink's `Error`, returning a new sink. Read more

#### `fn buffer(self, amt: usize) -> Buffer<Self> where
Self: Sized,`
[src]

Adds a fixed-size buffer to the current sink. Read more

#### `fn fanout<S>(self, other: S) -> Fanout<Self, S> where
Self: Sized,
Self::SinkItem: Clone,
S: Sink<SinkItem = Self::SinkItem, SinkError = Self::SinkError>,`
[src]

Fanout items to multiple sinks. Read more

#### `fn flush(self) -> Flush<Self> where
Self: Sized,`
[src]

A future that completes when the sink has finished processing all pending requests. Read more

#### `fn send(self, item: Self::SinkItem) -> Send<Self> where
Self: Sized,`
[src]

A future that completes after the given item has been fully processed into the sink, including flushing. Read more

#### `fn send_all<S>(self, stream: S) -> SendAll<Self, S> where
S: Stream<Item = Self::SinkItem>,
Self::SinkError: From<S::Error>,
Self: Sized,`
[src]

A future that completes after the given stream has been fully processed into the sink, including flushing. Read more

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

#### `fn clone(&self) -> Sender<T>`
[src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`
1.0.0
[src]

Performs copy-assignment from `source`. 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`)