Trait futures::prelude::Sink

#[must_use = "sinks do nothing unless polled"]
pub trait Sink<Item> {
    type 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>>;
}

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

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.

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.

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.

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<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 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<'_, 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 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<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>>

Loading content...

Implementors

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<A, B, Item> Sink<Item> for Either<A, B> where
    B: Sink<Item, Error = <A as Sink<Item>>::Error>,
    A: Sink<Item>, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Error = E

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

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

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

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

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

type Error = E

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

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

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

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

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

type Error = E

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Error = E

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

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

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

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

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

type Error = E

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

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

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

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

impl<S, SinkItem> Sink<SinkItem> for Compat01As03Sink<S, SinkItem> where
    S: Sink<SinkItem = SinkItem>, 

type Error = <S as Sink>::SinkError

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

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

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

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

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

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

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

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

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

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

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

type Error = E

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

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

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

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

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

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

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

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

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

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

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

type Error = E

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

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

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

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

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

type Error = E

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

pub fn start_send(
    self: Pin<&mut With<Si, Item, U, Fut, F>>,
    item: U
) -> Result<(), <With<Si, Item, U, Fut, F> as Sink<U>>::Error>

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

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

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

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

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

pub fn start_send(
    self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>,
    item: U
) -> Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>

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

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

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

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

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

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

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

pub fn poll_close(
    self: Pin<&mut Map<St, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <Map<St, F> as Sink<Item>>::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>>

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 Drain<T>

type Error = Infallible

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

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

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

pub fn poll_close(
    self: Pin<&mut Drain<T>>,
    _cx: &mut Context<'_>
) -> Poll<Result<(), <Drain<T> as Sink<T>>::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

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

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

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

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

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

type Error = Error

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

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

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

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

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

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

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

pub fn start_send(
    self: Pin<&mut FlattenStream<F>>,
    item: _Item
) -> Result<(), <FlattenStream<F> as Sink<_Item>>::Error>

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

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

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

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

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

pub fn start_send(
    self: Pin<&mut TryFlattenStream<Fut>>,
    item: _Item
) -> Result<(), <TryFlattenStream<Fut> as Sink<_Item>>::Error>

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

pub fn poll_close(
    self: Pin<&mut TryFlattenStream<Fut>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <TryFlattenStream<Fut> as Sink<_Item>>::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

pub fn poll_ready(
    self: Pin<&mut FlattenSink<Fut, Si>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <FlattenSink<Fut, Si> as Sink<_Item>>::Error>>

pub fn start_send(
    self: Pin<&mut FlattenSink<Fut, Si>>,
    item: _Item
) -> Result<(), <FlattenSink<Fut, Si> as Sink<_Item>>::Error>

pub fn poll_flush(
    self: Pin<&mut FlattenSink<Fut, Si>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <FlattenSink<Fut, Si> as Sink<_Item>>::Error>>

pub fn poll_close(
    self: Pin<&mut FlattenSink<Fut, Si>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <FlattenSink<Fut, Si> as Sink<_Item>>::Error>>

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

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

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

pub fn start_send(
    self: Pin<&mut Flatten<St>>,
    item: _Item
) -> Result<(), <Flatten<St> as Sink<_Item>>::Error>

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

pub fn poll_close(
    self: Pin<&mut Flatten<St>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <Flatten<St> as Sink<_Item>>::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

pub fn poll_ready(
    self: Pin<&mut ErrInto<St, E>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <ErrInto<St, E> as Sink<_Item>>::Error>>

pub fn start_send(
    self: Pin<&mut ErrInto<St, E>>,
    item: _Item
) -> Result<(), <ErrInto<St, E> as Sink<_Item>>::Error>

pub fn poll_flush(
    self: Pin<&mut ErrInto<St, E>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <ErrInto<St, E> as Sink<_Item>>::Error>>

pub fn poll_close(
    self: Pin<&mut ErrInto<St, E>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <ErrInto<St, E> as Sink<_Item>>::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

pub fn poll_ready(
    self: Pin<&mut Inspect<St, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <Inspect<St, F> as Sink<_Item>>::Error>>

pub fn start_send(
    self: Pin<&mut Inspect<St, F>>,
    item: _Item
) -> Result<(), <Inspect<St, F> as Sink<_Item>>::Error>

pub fn poll_flush(
    self: Pin<&mut Inspect<St, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <Inspect<St, F> as Sink<_Item>>::Error>>

pub fn poll_close(
    self: Pin<&mut Inspect<St, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <Inspect<St, F> as Sink<_Item>>::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

pub fn poll_ready(
    self: Pin<&mut InspectErr<St, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <InspectErr<St, F> as Sink<_Item>>::Error>>

pub fn start_send(
    self: Pin<&mut InspectErr<St, F>>,
    item: _Item
) -> Result<(), <InspectErr<St, F> as Sink<_Item>>::Error>

pub fn poll_flush(
    self: Pin<&mut InspectErr<St, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <InspectErr<St, F> as Sink<_Item>>::Error>>

pub fn poll_close(
    self: Pin<&mut InspectErr<St, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <InspectErr<St, F> as Sink<_Item>>::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

pub fn poll_ready(
    self: Pin<&mut InspectOk<St, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <InspectOk<St, F> as Sink<_Item>>::Error>>

pub fn start_send(
    self: Pin<&mut InspectOk<St, F>>,
    item: _Item
) -> Result<(), <InspectOk<St, F> as Sink<_Item>>::Error>

pub fn poll_flush(
    self: Pin<&mut InspectOk<St, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <InspectOk<St, F> as Sink<_Item>>::Error>>

pub fn poll_close(
    self: Pin<&mut InspectOk<St, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <InspectOk<St, F> as Sink<_Item>>::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

pub fn poll_ready(
    self: Pin<&mut MapErr<St, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <MapErr<St, F> as Sink<_Item>>::Error>>

pub fn start_send(
    self: Pin<&mut MapErr<St, F>>,
    item: _Item
) -> Result<(), <MapErr<St, F> as Sink<_Item>>::Error>

pub fn poll_flush(
    self: Pin<&mut MapErr<St, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <MapErr<St, F> as Sink<_Item>>::Error>>

pub fn poll_close(
    self: Pin<&mut MapErr<St, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <MapErr<St, F> as Sink<_Item>>::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

pub fn poll_ready(
    self: Pin<&mut MapOk<St, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <MapOk<St, F> as Sink<_Item>>::Error>>

pub fn start_send(
    self: Pin<&mut MapOk<St, F>>,
    item: _Item
) -> Result<(), <MapOk<St, F> as Sink<_Item>>::Error>

pub fn poll_flush(
    self: Pin<&mut MapOk<St, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <MapOk<St, F> as Sink<_Item>>::Error>>

pub fn poll_close(
    self: Pin<&mut MapOk<St, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <MapOk<St, F> as Sink<_Item>>::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

pub fn poll_ready(
    self: Pin<&mut FlatMap<St, U, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <FlatMap<St, U, F> as Sink<_Item>>::Error>>

pub fn start_send(
    self: Pin<&mut FlatMap<St, U, F>>,
    item: _Item
) -> Result<(), <FlatMap<St, U, F> as Sink<_Item>>::Error>

pub fn poll_flush(
    self: Pin<&mut FlatMap<St, U, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <FlatMap<St, U, F> as Sink<_Item>>::Error>>

pub fn poll_close(
    self: Pin<&mut FlatMap<St, U, F>>,
    cx: &mut Context<'_>
) -> Poll<Result<(), <FlatMap<St, U, F> as Sink<_Item>>::Error>>

Loading content...