Trait futures_util::sink::Sink

#[must_use = "sinks do nothing unless polled"]pub trait Sink<Item> {
    type Error;
    pub fn poll_ready(
        self: Pin<&mut Self>, 
        cx: &mut Context<'_>
    ) -> Poll<Result<(), Self::Error>>;
    pub fn start_send(
        self: Pin<&mut Self>, 
        item: Item
    ) -> Result<(), Self::Error>;
    pub fn poll_flush(
        self: Pin<&mut Self>, 
        cx: &mut Context<'_>
    ) -> Poll<Result<(), Self::Error>>;
    pub fn poll_close(
        self: Pin<&mut Self>, 
        cx: &mut Context<'_>
    ) -> Poll<Result<(), Self::Error>>;
}

A Sink is a value into which other values can be sent, asynchronously.

Basic examples of sinks include the sending side of:

• Channels
• Sockets
• Pipes

In addition to such "primitive" sinks, it's typical to layer additional functionality, such as buffering, on top of an existing sink.

Sending to a sink is "asynchronous" in the sense that the value may not be sent in its entirety immediately. Instead, values are sent in a two-phase way: first by initiating a send, and then by polling for completion. This two-phase setup is analogous to buffered writing in synchronous code, where writes often succeed immediately, but internally are buffered and are actually written only upon flushing.

In addition, the Sink may be full, in which case it is not even possible to start the sending process.

As with Future and Stream, the Sink trait is built from a few core required methods, and a host of default methods for working in a higher-level way. The Sink::send_all combinator is of particular importance: you can use it to send an entire stream to a sink, which is the simplest way to ultimately consume a stream.

Associated Types

type Error

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

Loading content...

Required methods

pub fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

This method must be called and return Poll::Ready(Ok(())) prior to each call to start_send.

This method returns Poll::Ready once the underlying sink is ready to receive data. If this method returns Poll::Pending, the current task is registered to be notified (via cx.waker().wake_by_ref()) when poll_ready should be called again.

In most cases, if the sink encounters an error, the sink will permanently be unable to receive items.

pub fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

As the name suggests, this method only begins the process of sending the item. If the sink employs buffering, the item isn't fully processed until the buffer is fully flushed. Since sinks are designed to work with asynchronous I/O, the process of actually writing out the data to an underlying object takes place asynchronously. You must use poll_flush or poll_close in order to guarantee completion of a send.

Implementations of poll_ready and start_send will usually involve flushing behind the scenes in order to make room for new messages. It is only necessary to call poll_flush if you need to guarantee that all of the items placed into the Sink have been sent.

In most cases, if the sink encounters an error, the sink will permanently be unable to receive items.

pub fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

Returns Poll::Ready(Ok(())) when no buffered items remain. If this value is returned then it is guaranteed that all previous values sent via start_send have been flushed.

Returns Poll::Pending if there is more work left to do, in which case the current task is scheduled (via cx.waker().wake_by_ref()) to wake up when poll_flush should be called again.

In most cases, if the sink encounters an error, the sink will permanently be unable to receive items.

pub fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

Returns Poll::Ready(Ok(())) when no buffered items remain and the sink has been successfully closed.

Returns Poll::Pending if there is more work left to do, in which case the current task is scheduled (via cx.waker().wake_by_ref()) to wake up when poll_close should be called again.

If this function encounters an error, the sink should be considered to have failed permanently, and no more Sink methods should be called.

Loading content...

Implementations on Foreign Types

impl<S, Item> Sink<Item> for Box<S, Global> where
    S: Sink<Item> + Unpin + ?Sized, 

type Error = <S as Sink<Item>>::Error

pub fn poll_ready(
    self: Pin<&mut Box<S, Global>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <Box<S, Global> as Sink<Item>>::Error>>

pub fn start_send(
    self: Pin<&mut Box<S, Global>>,
    item: Item
) -> Result<(), <Box<S, Global> as Sink<Item>>::Error>

pub fn poll_flush(
    self: Pin<&mut Box<S, Global>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <Box<S, Global> as Sink<Item>>::Error>>

pub fn poll_close(
    self: Pin<&mut Box<S, Global>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <Box<S, Global> as Sink<Item>>::Error>>

impl<'_, S, Item> Sink<Item> for &'_ mut S where
    S: Sink<Item> + Unpin + ?Sized, 

type Error = <S as Sink<Item>>::Error

pub fn poll_ready(
    self: Pin<&mut &'_ mut S>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <&'_ mut S as Sink<Item>>::Error>>

pub fn start_send(
    self: Pin<&mut &'_ mut S>,
    item: Item
) -> Result<(), <&'_ mut S as Sink<Item>>::Error>

pub fn poll_flush(
    self: Pin<&mut &'_ mut S>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <&'_ mut S as Sink<Item>>::Error>>

pub fn poll_close(
    self: Pin<&mut &'_ mut S>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <&'_ mut S as Sink<Item>>::Error>>

impl<T> Sink<T> for VecDeque<T>

type Error = Infallible

pub fn poll_ready(
    self: Pin<&mut VecDeque<T>>,
    &mut Context<'_>
) -> Poll<Result<(), <VecDeque<T> as Sink<T>>::Error>>

pub fn start_send(
    self: Pin<&mut VecDeque<T>>,
    item: T
) -> Result<(), <VecDeque<T> as Sink<T>>::Error>

pub fn poll_flush(
    self: Pin<&mut VecDeque<T>>,
    &mut Context<'_>
) -> Poll<Result<(), <VecDeque<T> as Sink<T>>::Error>>

pub fn poll_close(
    self: Pin<&mut VecDeque<T>>,
    &mut Context<'_>
) -> Poll<Result<(), <VecDeque<T> as Sink<T>>::Error>>

impl<T> Sink<T> for Vec<T, Global>

type Error = Infallible

pub fn poll_ready(
    self: Pin<&mut Vec<T, Global>>,
    &mut Context<'_>
) -> Poll<Result<(), <Vec<T, Global> as Sink<T>>::Error>>

pub fn start_send(
    self: Pin<&mut Vec<T, Global>>,
    item: T
) -> Result<(), <Vec<T, Global> as Sink<T>>::Error>

pub fn poll_flush(
    self: Pin<&mut Vec<T, Global>>,
    &mut Context<'_>
) -> Poll<Result<(), <Vec<T, Global> as Sink<T>>::Error>>

pub fn poll_close(
    self: Pin<&mut Vec<T, Global>>,
    &mut Context<'_>
) -> Poll<Result<(), <Vec<T, Global> as Sink<T>>::Error>>

impl<P, Item> Sink<Item> for Pin<P> where
    P: DerefMut + Unpin,
    <P as Deref>::Target: Sink<Item>, 

type Error = <<P as Deref>::Target as Sink<Item>>::Error

pub fn poll_ready(
    self: Pin<&mut Pin<P>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <Pin<P> as Sink<Item>>::Error>>

pub fn start_send(
    self: Pin<&mut Pin<P>>,
    item: Item
) -> Result<(), <Pin<P> as Sink<Item>>::Error>

pub fn poll_flush(
    self: Pin<&mut Pin<P>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <Pin<P> as Sink<Item>>::Error>>

pub fn poll_close(
    self: Pin<&mut Pin<P>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <Pin<P> as Sink<Item>>::Error>>

impl<'_, T> Sink<T> for &'_ UnboundedSender<T>

type Error = SendError

pub fn poll_ready(
    self: Pin<&mut &'_ UnboundedSender<T>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <&'_ UnboundedSender<T> as Sink<T>>::Error>>

pub fn start_send(
    self: Pin<&mut &'_ UnboundedSender<T>>,
    msg: T
) -> Result<(), <&'_ UnboundedSender<T> as Sink<T>>::Error>

pub fn poll_flush(
    self: Pin<&mut &'_ UnboundedSender<T>>,
    &mut Context<'_>
) -> Poll<Result<(), <&'_ UnboundedSender<T> as Sink<T>>::Error>>

pub fn poll_close(
    self: Pin<&mut &'_ UnboundedSender<T>>,
    &mut Context<'_>
) -> Poll<Result<(), <&'_ UnboundedSender<T> as Sink<T>>::Error>>

impl<T> Sink<T> for UnboundedSender<T>

type Error = SendError

pub fn poll_ready(
    self: Pin<&mut UnboundedSender<T>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <UnboundedSender<T> as Sink<T>>::Error>>

pub fn start_send(
    self: Pin<&mut UnboundedSender<T>>,
    msg: T
) -> Result<(), <UnboundedSender<T> as Sink<T>>::Error>

pub fn poll_flush(
    self: Pin<&mut UnboundedSender<T>>,
    &mut Context<'_>
) -> Poll<Result<(), <UnboundedSender<T> as Sink<T>>::Error>>

pub fn poll_close(
    self: Pin<&mut UnboundedSender<T>>,
    &mut Context<'_>
) -> Poll<Result<(), <UnboundedSender<T> as Sink<T>>::Error>>

impl<T> Sink<T> for Sender<T>

type Error = SendError

pub fn poll_ready(
    self: Pin<&mut Sender<T>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <Sender<T> as Sink<T>>::Error>>

pub fn start_send(
    self: Pin<&mut Sender<T>>,
    msg: T
) -> Result<(), <Sender<T> as Sink<T>>::Error>

pub fn poll_flush(
    self: Pin<&mut Sender<T>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <Sender<T> as Sink<T>>::Error>>

pub fn poll_close(
    self: Pin<&mut Sender<T>>,
    &mut Context<'_>
) -> Poll<Result<(), <Sender<T> as Sink<T>>::Error>>

Loading content...

Implementors

impl<A, B, Item> Sink<Item> for Either<A, B> where
    A: Sink<Item>,
    B: Sink<Item, Error = A::Error>, 

type Error = A::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Fut, F, Item> Sink<Item> for AndThen<S, Fut, F> where
    S: Sink<Item>, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Fut, F, Item> Sink<Item> for Filter<S, Fut, F> where
    S: Stream + Sink<Item>,
    F: FnMut(&S::Item) -> Fut,
    Fut: Future<Output = bool>, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Fut, F, Item> Sink<Item> for FilterMap<S, Fut, F> where
    S: Stream + Sink<Item>,
    F: FnMut1<S::Item, Output = Fut>,
    Fut: Future, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Fut, F, Item> Sink<Item> for OrElse<S, Fut, F> where
    S: Sink<Item>, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Fut, F, Item> Sink<Item> for Scan<S, S, Fut, F> where
    S: Stream + Sink<Item>, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Fut, F, Item> Sink<Item> for SkipWhile<S, Fut, F> where
    S: Stream + Sink<Item>,
    F: FnMut(&S::Item) -> Fut,
    Fut: Future<Output = bool>, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Fut, F, Item> Sink<Item> for TakeWhile<S, Fut, F> where
    S: Stream + Sink<Item>, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Fut, F, Item> Sink<Item> for Then<S, Fut, F> where
    S: Sink<Item>, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Fut, F, Item> Sink<Item> for TryFilterMap<S, Fut, F> where
    S: Sink<Item>, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Fut, F, Item, E> Sink<Item> for TryFilter<S, Fut, F> where
    S: TryStream + Sink<Item, Error = E>, 

type Error = E

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Fut, F, Item, E> Sink<Item> for TrySkipWhile<S, Fut, F> where
    S: TryStream + Sink<Item, Error = E>, 

type Error = E

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Fut, F, Item, E> Sink<Item> for TryTakeWhile<S, Fut, F> where
    S: TryStream + Sink<Item, Error = E>, 

type Error = E

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Fut, Item> Sink<Item> for TakeUntil<S, Fut> where
    S: Stream + Sink<Item>,
    Fut: Future, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Item> Sink<Item> for BufferUnordered<S> where
    S: Stream + Sink<Item>,
    S::Item: Future, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Item> Sink<Item> for Buffered<S> where
    S: Stream + Sink<Item>,
    S::Item: Future, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Item> Sink<Item> for Chunks<S> where
    S: Stream + Sink<Item>, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Item> Sink<Item> for Enumerate<S> where
    S: Stream + Sink<Item>, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Item> Sink<Item> for Peekable<S> where
    S: Sink<Item> + Stream, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Item> Sink<Item> for ReadyChunks<S> where
    S: Stream + Sink<Item>, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Item> Sink<Item> for Skip<S> where
    S: Stream + Sink<Item>, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Item> Sink<Item> for Take<S> where
    S: Stream + Sink<Item>, 

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Item> Sink<Item> for TryFlatten<S> where
    S: TryStream + Sink<Item>, 

type Error = <S as Sink<Item>>::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Item, E> Sink<Item> for TryBufferUnordered<S> where
    S: TryStream + Sink<Item, Error = E>,
    S::Ok: TryFuture<Error = E>, 

type Error = E

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S, Item, E> Sink<Item> for TryBuffered<S> where
    S: TryStream + Sink<Item, Error = E>,
    S::Ok: TryFuture<Error = E>, 

type Error = E

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S: Sink<Item>, Item> Sink<Item> for IntoStream<S>

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<S: Sink<Item>, Item> Sink<Item> for SplitSink<S, Item>

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), S::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), S::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), S::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), S::Error>>

impl<S: Stream + Sink<Item>, Item> Sink<Item> for Fuse<S>

type Error = S::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<Si1, Si2, Item> Sink<Item> for Fanout<Si1, Si2> where
    Si1: Sink<Item>,
    Item: Clone,
    Si2: Sink<Item, Error = Si1::Error>, 

type Error = Si1::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<Si, F, E, Item> Sink<Item> for SinkMapErr<Si, F> where
    Si: Sink<Item>,
    F: FnOnce(Si::Error) -> E, 

type Error = E

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<Si, Item, E> Sink<Item> for SinkErrInto<Si, Item, E> where
    Si: Sink<Item>,
    Si::Error: Into<E>, 

type Error = E

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<Si, Item, U, Fut, F, E> Sink<U> for With<Si, Item, U, Fut, F> where
    Si: Sink<Item>,
    F: FnMut(U) -> Fut,
    Fut: Future<Output = Result<Item, E>>,
    E: From<Si::Error>, 

type Error = E

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: U) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<Si, Item, U, St, F> Sink<U> for WithFlatMap<Si, Item, U, St, F> where
    Si: Sink<Item>,
    F: FnMut(U) -> St,
    St: Stream<Item = Result<Item, Si::Error>>, 

type Error = Si::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: U) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<Si: Sink<Item>, Item> Sink<Item> for Buffer<Si, Item>

type Error = Si::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<St, F, Item> Sink<Item> for Map<St, F> where
    St: Stream + Sink<Item>,
    F: FnMut1<St::Item>, 

type Error = St::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<T> Sink<T> for Drain<T>

type Error = Never

fn poll_ready(
    self: Pin<&mut Self>,
    _cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, _item: T) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    _cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    _cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<T, F, R, Item, E> Sink<Item> for Unfold<T, F, R> where
    F: FnMut(T, Item) -> R,
    R: Future<Output = Result<T, E>>, 

type Error = E

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<W: AsyncWrite, Item: AsRef<[u8]>> Sink<Item> for IntoSink<W, Item>

type Error = Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<_Item, F> Sink<_Item> for FlattenStream<F> where
    Flatten<F, <F as Future>::Output>: Sink<_Item>,
    F: Future, 

type Error = <Flatten<F, <F as Future>::Output> as Sink<_Item>>::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<_Item, Fut> Sink<_Item> for TryFlattenStream<Fut> where
    TryFlatten<Fut, Fut::Ok>: Sink<_Item>,
    Fut: TryFuture, 

type Error = <TryFlatten<Fut, Fut::Ok> as Sink<_Item>>::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<_Item, Fut, Si> Sink<_Item> for FlattenSink<Fut, Si> where
    TryFlatten<Fut, Si>: Sink<_Item>, 

type Error = <TryFlatten<Fut, Si> as Sink<_Item>>::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<_Item, St> Sink<_Item> for Flatten<St> where
    Flatten<St, St::Item>: Sink<_Item>,
    St: Stream, 

type Error = <Flatten<St, St::Item> as Sink<_Item>>::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<_Item, St, E> Sink<_Item> for ErrInto<St, E> where
    MapErr<St, IntoFn<E>>: Sink<_Item>, 

type Error = <MapErr<St, IntoFn<E>> as Sink<_Item>>::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<_Item, St, F> Sink<_Item> for Inspect<St, F> where
    Map<St, InspectFn<F>>: Sink<_Item>, 

type Error = <Map<St, InspectFn<F>> as Sink<_Item>>::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<_Item, St, F> Sink<_Item> for InspectErr<St, F> where
    Inspect<IntoStream<St>, InspectErrFn<F>>: Sink<_Item>, 

type Error = <Inspect<IntoStream<St>, InspectErrFn<F>> as Sink<_Item>>::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<_Item, St, F> Sink<_Item> for InspectOk<St, F> where
    Inspect<IntoStream<St>, InspectOkFn<F>>: Sink<_Item>, 

type Error = <Inspect<IntoStream<St>, InspectOkFn<F>> as Sink<_Item>>::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<_Item, St, F> Sink<_Item> for MapErr<St, F> where
    Map<IntoStream<St>, MapErrFn<F>>: Sink<_Item>, 

type Error = <Map<IntoStream<St>, MapErrFn<F>> as Sink<_Item>>::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<_Item, St, F> Sink<_Item> for MapOk<St, F> where
    Map<IntoStream<St>, MapOkFn<F>>: Sink<_Item>, 

type Error = <Map<IntoStream<St>, MapOkFn<F>> as Sink<_Item>>::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

impl<_Item, St, U, F> Sink<_Item> for FlatMap<St, U, F> where
    Flatten<Map<St, F>, U>: Sink<_Item>, 

type Error = <Flatten<Map<St, F>, U> as Sink<_Item>>::Error

fn poll_ready(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

Loading content...