[−][src]Trait futures::sink::Sink
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 SinkError
The type of value produced by the sink when an error occurs.
Required methods
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context
) -> Poll<Result<(), Self::SinkError>>
self: Pin<&mut Self>,
cx: &mut Context
) -> Poll<Result<(), Self::SinkError>>
Attempts to prepare the Sink
to receive a value.
This method must be called and return Ok(Poll::Ready(()))
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::SinkError>
Begin the process of sending a value to the sink.
Each call to this function must be proceeded by a successful call to
poll_ready
which returned Ok(Poll::Ready(()))
.
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::SinkError>>
self: Pin<&mut Self>,
cx: &mut Context
) -> Poll<Result<(), Self::SinkError>>
Flush any remaining output from this sink.
Returns Ok(Poll::Ready(()))
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 Ok(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::SinkError>>
self: Pin<&mut Self>,
cx: &mut Context
) -> Poll<Result<(), Self::SinkError>>
Flush any remaining output and close this sink, if necessary.
Returns Ok(Poll::Ready(()))
when no buffered items remain and the sink
has been successfully closed.
Returns Ok(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.
Implementations on Foreign Types
impl<A, B, Item> Sink<Item> for Either<A, B> where
A: Sink<Item>,
B: Sink<Item, SinkError = <A as Sink<Item>>::SinkError>,
[src]
A: Sink<Item>,
B: Sink<Item, SinkError = <A as Sink<Item>>::SinkError>,
type SinkError = <A as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut Either<A, B>>,
cx: &mut Context
) -> Poll<Result<(), <Either<A, B> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Either<A, B>>,
cx: &mut Context
) -> Poll<Result<(), <Either<A, B> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut Either<A, B>>,
item: Item
) -> Result<(), <Either<A, B> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut Either<A, B>>,
item: Item
) -> Result<(), <Either<A, B> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut Either<A, B>>,
cx: &mut Context
) -> Poll<Result<(), <Either<A, B> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Either<A, B>>,
cx: &mut Context
) -> Poll<Result<(), <Either<A, B> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut Either<A, B>>,
cx: &mut Context
) -> Poll<Result<(), <Either<A, B> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Either<A, B>>,
cx: &mut Context
) -> Poll<Result<(), <Either<A, B> as Sink<Item>>::SinkError>>
impl<'a, S, Item> Sink<Item> for Pin<&'a mut S> where
S: Sink<Item> + ?Sized,
[src]
S: Sink<Item> + ?Sized,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut Pin<&'a mut S>>,
cx: &mut Context
) -> Poll<Result<(), <Pin<&'a mut S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Pin<&'a mut S>>,
cx: &mut Context
) -> Poll<Result<(), <Pin<&'a mut S> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut Pin<&'a mut S>>,
item: Item
) -> Result<(), <Pin<&'a mut S> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut Pin<&'a mut S>>,
item: Item
) -> Result<(), <Pin<&'a mut S> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut Pin<&'a mut S>>,
cx: &mut Context
) -> Poll<Result<(), <Pin<&'a mut S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Pin<&'a mut S>>,
cx: &mut Context
) -> Poll<Result<(), <Pin<&'a mut S> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut Pin<&'a mut S>>,
cx: &mut Context
) -> Poll<Result<(), <Pin<&'a mut S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Pin<&'a mut S>>,
cx: &mut Context
) -> Poll<Result<(), <Pin<&'a mut S> as Sink<Item>>::SinkError>>
impl<T> Sink<T> for VecDeque<T>
[src]
type SinkError = VecSinkError
fn poll_ready(
self: Pin<&mut VecDeque<T>>,
&mut Context
) -> Poll<Result<(), <VecDeque<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut VecDeque<T>>,
&mut Context
) -> Poll<Result<(), <VecDeque<T> as Sink<T>>::SinkError>>
fn start_send(
self: Pin<&mut VecDeque<T>>,
item: T
) -> Result<(), <VecDeque<T> as Sink<T>>::SinkError>
[src]
self: Pin<&mut VecDeque<T>>,
item: T
) -> Result<(), <VecDeque<T> as Sink<T>>::SinkError>
fn poll_flush(
self: Pin<&mut VecDeque<T>>,
&mut Context
) -> Poll<Result<(), <VecDeque<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut VecDeque<T>>,
&mut Context
) -> Poll<Result<(), <VecDeque<T> as Sink<T>>::SinkError>>
fn poll_close(
self: Pin<&mut VecDeque<T>>,
&mut Context
) -> Poll<Result<(), <VecDeque<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut VecDeque<T>>,
&mut Context
) -> Poll<Result<(), <VecDeque<T> as Sink<T>>::SinkError>>
impl<S, Item> Sink<Item> for Box<S> where
S: Sink<Item> + Unpin + ?Sized,
[src]
S: Sink<Item> + Unpin + ?Sized,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut Box<S>>,
cx: &mut Context
) -> Poll<Result<(), <Box<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Box<S>>,
cx: &mut Context
) -> Poll<Result<(), <Box<S> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut Box<S>>,
item: Item
) -> Result<(), <Box<S> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut Box<S>>,
item: Item
) -> Result<(), <Box<S> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut Box<S>>,
cx: &mut Context
) -> Poll<Result<(), <Box<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Box<S>>,
cx: &mut Context
) -> Poll<Result<(), <Box<S> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut Box<S>>,
cx: &mut Context
) -> Poll<Result<(), <Box<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Box<S>>,
cx: &mut Context
) -> Poll<Result<(), <Box<S> as Sink<Item>>::SinkError>>
impl<'a, S, Item> Sink<Item> for &'a mut S where
S: Sink<Item> + Unpin + ?Sized,
[src]
S: Sink<Item> + Unpin + ?Sized,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut &'a mut S>,
cx: &mut Context
) -> Poll<Result<(), <&'a mut S as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut &'a mut S>,
cx: &mut Context
) -> Poll<Result<(), <&'a mut S as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut &'a mut S>,
item: Item
) -> Result<(), <&'a mut S as Sink<Item>>::SinkError>
[src]
self: Pin<&mut &'a mut S>,
item: Item
) -> Result<(), <&'a mut S as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut &'a mut S>,
cx: &mut Context
) -> Poll<Result<(), <&'a mut S as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut &'a mut S>,
cx: &mut Context
) -> Poll<Result<(), <&'a mut S as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut &'a mut S>,
cx: &mut Context
) -> Poll<Result<(), <&'a mut S as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut &'a mut S>,
cx: &mut Context
) -> Poll<Result<(), <&'a mut S as Sink<Item>>::SinkError>>
impl<T> Sink<T> for Vec<T>
[src]
type SinkError = VecSinkError
fn poll_ready(
self: Pin<&mut Vec<T>>,
&mut Context
) -> Poll<Result<(), <Vec<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut Vec<T>>,
&mut Context
) -> Poll<Result<(), <Vec<T> as Sink<T>>::SinkError>>
fn start_send(
self: Pin<&mut Vec<T>>,
item: T
) -> Result<(), <Vec<T> as Sink<T>>::SinkError>
[src]
self: Pin<&mut Vec<T>>,
item: T
) -> Result<(), <Vec<T> as Sink<T>>::SinkError>
fn poll_flush(
self: Pin<&mut Vec<T>>,
&mut Context
) -> Poll<Result<(), <Vec<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut Vec<T>>,
&mut Context
) -> Poll<Result<(), <Vec<T> as Sink<T>>::SinkError>>
fn poll_close(
self: Pin<&mut Vec<T>>,
&mut Context
) -> Poll<Result<(), <Vec<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut Vec<T>>,
&mut Context
) -> Poll<Result<(), <Vec<T> as Sink<T>>::SinkError>>
Implementors
impl<'a, T> Sink<T> for &'a UnboundedSender<T>
[src]
type SinkError = SendError
fn poll_ready(
self: Pin<&mut &'a UnboundedSender<T>>,
cx: &mut Context
) -> Poll<Result<(), <&'a UnboundedSender<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut &'a UnboundedSender<T>>,
cx: &mut Context
) -> Poll<Result<(), <&'a UnboundedSender<T> as Sink<T>>::SinkError>>
fn start_send(
self: Pin<&mut &'a UnboundedSender<T>>,
msg: T
) -> Result<(), <&'a UnboundedSender<T> as Sink<T>>::SinkError>
[src]
self: Pin<&mut &'a UnboundedSender<T>>,
msg: T
) -> Result<(), <&'a UnboundedSender<T> as Sink<T>>::SinkError>
fn poll_flush(
self: Pin<&mut &'a UnboundedSender<T>>,
&mut Context
) -> Poll<Result<(), <&'a UnboundedSender<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut &'a UnboundedSender<T>>,
&mut Context
) -> Poll<Result<(), <&'a UnboundedSender<T> as Sink<T>>::SinkError>>
fn poll_close(
self: Pin<&mut &'a UnboundedSender<T>>,
&mut Context
) -> Poll<Result<(), <&'a UnboundedSender<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut &'a UnboundedSender<T>>,
&mut Context
) -> Poll<Result<(), <&'a UnboundedSender<T> as Sink<T>>::SinkError>>
impl<Fut, Si, Item> Sink<Item> for FlattenSink<Fut, Si> where
Fut: TryFuture<Ok = Si>,
Si: Sink<Item, SinkError = <Fut as TryFuture>::Error>,
[src]
Fut: TryFuture<Ok = Si>,
Si: Sink<Item, SinkError = <Fut as TryFuture>::Error>,
type SinkError = <Si as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut FlattenSink<Fut, Si>>,
cx: &mut Context
) -> Poll<Result<(), <FlattenSink<Fut, Si> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut FlattenSink<Fut, Si>>,
cx: &mut Context
) -> Poll<Result<(), <FlattenSink<Fut, Si> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut FlattenSink<Fut, Si>>,
item: Item
) -> Result<(), <FlattenSink<Fut, Si> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut FlattenSink<Fut, Si>>,
item: Item
) -> Result<(), <FlattenSink<Fut, Si> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut FlattenSink<Fut, Si>>,
cx: &mut Context
) -> Poll<Result<(), <FlattenSink<Fut, Si> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut FlattenSink<Fut, Si>>,
cx: &mut Context
) -> Poll<Result<(), <FlattenSink<Fut, Si> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut FlattenSink<Fut, Si>>,
cx: &mut Context
) -> Poll<Result<(), <FlattenSink<Fut, Si> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut FlattenSink<Fut, Si>>,
cx: &mut Context
) -> Poll<Result<(), <FlattenSink<Fut, Si> as Sink<Item>>::SinkError>>
impl<S, E, Item> Sink<Item> for ErrInto<S, E> where
S: TryStream + Sink<Item>,
<S as TryStream>::Error: Into<E>,
[src]
S: TryStream + Sink<Item>,
<S as TryStream>::Error: Into<E>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut ErrInto<S, E>>,
cx: &mut Context
) -> Poll<Result<(), <ErrInto<S, E> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut ErrInto<S, E>>,
cx: &mut Context
) -> Poll<Result<(), <ErrInto<S, E> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut ErrInto<S, E>>,
item: Item
) -> Result<(), <ErrInto<S, E> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut ErrInto<S, E>>,
item: Item
) -> Result<(), <ErrInto<S, E> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut ErrInto<S, E>>,
cx: &mut Context
) -> Poll<Result<(), <ErrInto<S, E> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut ErrInto<S, E>>,
cx: &mut Context
) -> Poll<Result<(), <ErrInto<S, E> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut ErrInto<S, E>>,
cx: &mut Context
) -> Poll<Result<(), <ErrInto<S, E> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut ErrInto<S, E>>,
cx: &mut Context
) -> Poll<Result<(), <ErrInto<S, E> as Sink<Item>>::SinkError>>
impl<S, F, E, Item> Sink<Item> for MapErr<S, F> where
F: FnMut(<S as TryStream>::Error) -> E,
S: TryStream + Sink<Item>,
[src]
F: FnMut(<S as TryStream>::Error) -> E,
S: TryStream + Sink<Item>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut MapErr<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <MapErr<S, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut MapErr<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <MapErr<S, F> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut MapErr<S, F>>,
item: Item
) -> Result<(), <MapErr<S, F> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut MapErr<S, F>>,
item: Item
) -> Result<(), <MapErr<S, F> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut MapErr<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <MapErr<S, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut MapErr<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <MapErr<S, F> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut MapErr<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <MapErr<S, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut MapErr<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <MapErr<S, F> as Sink<Item>>::SinkError>>
impl<S, F, Item> Sink<Item> for Inspect<S, F> where
F: FnMut(&<S as Stream>::Item),
S: Stream + Sink<Item>,
[src]
F: FnMut(&<S as Stream>::Item),
S: Stream + Sink<Item>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut Inspect<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <Inspect<S, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Inspect<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <Inspect<S, F> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut Inspect<S, F>>,
item: Item
) -> Result<(), <Inspect<S, F> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut Inspect<S, F>>,
item: Item
) -> Result<(), <Inspect<S, F> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut Inspect<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <Inspect<S, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Inspect<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <Inspect<S, F> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut Inspect<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <Inspect<S, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Inspect<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <Inspect<S, F> as Sink<Item>>::SinkError>>
impl<S, F, T, Item> Sink<Item> for Map<S, F> where
F: FnMut(<S as Stream>::Item) -> T,
S: Stream + Sink<Item>,
[src]
F: FnMut(<S as Stream>::Item) -> T,
S: Stream + Sink<Item>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut Map<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <Map<S, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Map<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <Map<S, F> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut Map<S, F>>,
item: Item
) -> Result<(), <Map<S, F> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut Map<S, F>>,
item: Item
) -> Result<(), <Map<S, F> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut Map<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <Map<S, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Map<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <Map<S, F> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut Map<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <Map<S, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Map<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <Map<S, F> as Sink<Item>>::SinkError>>
impl<S, F, T, Item> Sink<Item> for MapOk<S, F> where
F: FnMut(<S as TryStream>::Ok) -> T,
S: TryStream + Sink<Item>,
[src]
F: FnMut(<S as TryStream>::Ok) -> T,
S: TryStream + Sink<Item>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut MapOk<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <MapOk<S, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut MapOk<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <MapOk<S, F> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut MapOk<S, F>>,
item: Item
) -> Result<(), <MapOk<S, F> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut MapOk<S, F>>,
item: Item
) -> Result<(), <MapOk<S, F> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut MapOk<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <MapOk<S, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut MapOk<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <MapOk<S, F> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut MapOk<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <MapOk<S, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut MapOk<S, F>>,
cx: &mut Context
) -> Poll<Result<(), <MapOk<S, F> as Sink<Item>>::SinkError>>
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>,
[src]
F: FnMut(&<S as Stream>::Item) -> Fut,
Fut: Future<Output = bool>,
S: Stream + Sink<Item>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut Filter<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <Filter<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Filter<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <Filter<S, Fut, F> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut Filter<S, Fut, F>>,
item: Item
) -> Result<(), <Filter<S, Fut, F> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut Filter<S, Fut, F>>,
item: Item
) -> Result<(), <Filter<S, Fut, F> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut Filter<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <Filter<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Filter<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <Filter<S, Fut, F> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut Filter<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <Filter<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Filter<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <Filter<S, Fut, F> as Sink<Item>>::SinkError>>
impl<S, Fut, F, Item> Sink<Item> for FilterMap<S, Fut, F> where
F: FnMut(<S as Stream>::Item) -> Fut,
Fut: Future,
S: Stream + Sink<Item>,
[src]
F: FnMut(<S as Stream>::Item) -> Fut,
Fut: Future,
S: Stream + Sink<Item>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut FilterMap<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <FilterMap<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut FilterMap<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <FilterMap<S, Fut, F> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut FilterMap<S, Fut, F>>,
item: Item
) -> Result<(), <FilterMap<S, Fut, F> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut FilterMap<S, Fut, F>>,
item: Item
) -> Result<(), <FilterMap<S, Fut, F> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut FilterMap<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <FilterMap<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut FilterMap<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <FilterMap<S, Fut, F> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut FilterMap<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <FilterMap<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut FilterMap<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <FilterMap<S, Fut, F> as Sink<Item>>::SinkError>>
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>,
[src]
F: FnMut(&<S as Stream>::Item) -> Fut,
Fut: Future<Output = bool>,
S: Stream + Sink<Item>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut SkipWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <SkipWhile<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut SkipWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <SkipWhile<S, Fut, F> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut SkipWhile<S, Fut, F>>,
item: Item
) -> Result<(), <SkipWhile<S, Fut, F> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut SkipWhile<S, Fut, F>>,
item: Item
) -> Result<(), <SkipWhile<S, Fut, F> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut SkipWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <SkipWhile<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut SkipWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <SkipWhile<S, Fut, F> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut SkipWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <SkipWhile<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut SkipWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <SkipWhile<S, Fut, F> as Sink<Item>>::SinkError>>
impl<S, Fut, F, Item> Sink<Item> for TakeWhile<S, Fut, F> where
F: FnMut(&<S as Stream>::Item) -> Fut,
Fut: Future<Output = bool>,
S: Stream + Sink<Item>,
[src]
F: FnMut(&<S as Stream>::Item) -> Fut,
Fut: Future<Output = bool>,
S: Stream + Sink<Item>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut TakeWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TakeWhile<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut TakeWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TakeWhile<S, Fut, F> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut TakeWhile<S, Fut, F>>,
item: Item
) -> Result<(), <TakeWhile<S, Fut, F> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut TakeWhile<S, Fut, F>>,
item: Item
) -> Result<(), <TakeWhile<S, Fut, F> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut TakeWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TakeWhile<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut TakeWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TakeWhile<S, Fut, F> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut TakeWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TakeWhile<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut TakeWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TakeWhile<S, Fut, F> as Sink<Item>>::SinkError>>
impl<S, Fut, F, Item> Sink<Item> for Then<S, Fut, F> where
F: FnMut(<S as Stream>::Item) -> Fut,
Fut: Future,
S: Stream + Sink<Item>,
[src]
F: FnMut(<S as Stream>::Item) -> Fut,
Fut: Future,
S: Stream + Sink<Item>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut Then<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <Then<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Then<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <Then<S, Fut, F> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut Then<S, Fut, F>>,
item: Item
) -> Result<(), <Then<S, Fut, F> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut Then<S, Fut, F>>,
item: Item
) -> Result<(), <Then<S, Fut, F> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut Then<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <Then<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Then<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <Then<S, Fut, F> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut Then<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <Then<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Then<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <Then<S, Fut, F> as Sink<Item>>::SinkError>>
impl<S, Fut, F, Item> Sink<Item> for TrySkipWhile<S, Fut, F> where
F: FnMut(&<S as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = <S as TryStream>::Error>,
S: TryStream + Sink<Item>,
[src]
F: FnMut(&<S as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = <S as TryStream>::Error>,
S: TryStream + Sink<Item>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut TrySkipWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TrySkipWhile<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut TrySkipWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TrySkipWhile<S, Fut, F> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut TrySkipWhile<S, Fut, F>>,
item: Item
) -> Result<(), <TrySkipWhile<S, Fut, F> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut TrySkipWhile<S, Fut, F>>,
item: Item
) -> Result<(), <TrySkipWhile<S, Fut, F> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut TrySkipWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TrySkipWhile<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut TrySkipWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TrySkipWhile<S, Fut, F> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut TrySkipWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TrySkipWhile<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut TrySkipWhile<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TrySkipWhile<S, Fut, F> as Sink<Item>>::SinkError>>
impl<S, Fut, F, T, Item> Sink<Item> for TryFilterMap<S, Fut, F> where
F: FnMut(<S as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = Option<T>, Error = <S as TryStream>::Error>,
S: TryStream + Sink<Item>,
[src]
F: FnMut(<S as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = Option<T>, Error = <S as TryStream>::Error>,
S: TryStream + Sink<Item>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut TryFilterMap<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut TryFilterMap<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut TryFilterMap<S, Fut, F>>,
item: Item
) -> Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut TryFilterMap<S, Fut, F>>,
item: Item
) -> Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut TryFilterMap<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut TryFilterMap<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut TryFilterMap<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut TryFilterMap<S, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::SinkError>>
impl<S, Item> Sink<Item> for BufferUnordered<S> where
S: Stream + Sink<Item>,
<S as Stream>::Item: Future,
[src]
S: Stream + Sink<Item>,
<S as Stream>::Item: Future,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut BufferUnordered<S>>,
cx: &mut Context
) -> Poll<Result<(), <BufferUnordered<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut BufferUnordered<S>>,
cx: &mut Context
) -> Poll<Result<(), <BufferUnordered<S> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut BufferUnordered<S>>,
item: Item
) -> Result<(), <BufferUnordered<S> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut BufferUnordered<S>>,
item: Item
) -> Result<(), <BufferUnordered<S> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut BufferUnordered<S>>,
cx: &mut Context
) -> Poll<Result<(), <BufferUnordered<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut BufferUnordered<S>>,
cx: &mut Context
) -> Poll<Result<(), <BufferUnordered<S> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut BufferUnordered<S>>,
cx: &mut Context
) -> Poll<Result<(), <BufferUnordered<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut BufferUnordered<S>>,
cx: &mut Context
) -> Poll<Result<(), <BufferUnordered<S> as Sink<Item>>::SinkError>>
impl<S, Item> Sink<Item> for Buffered<S> where
S: Stream + Sink<Item>,
<S as Stream>::Item: Future,
[src]
S: Stream + Sink<Item>,
<S as Stream>::Item: Future,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut Buffered<S>>,
cx: &mut Context
) -> Poll<Result<(), <Buffered<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Buffered<S>>,
cx: &mut Context
) -> Poll<Result<(), <Buffered<S> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut Buffered<S>>,
item: Item
) -> Result<(), <Buffered<S> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut Buffered<S>>,
item: Item
) -> Result<(), <Buffered<S> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut Buffered<S>>,
cx: &mut Context
) -> Poll<Result<(), <Buffered<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Buffered<S>>,
cx: &mut Context
) -> Poll<Result<(), <Buffered<S> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut Buffered<S>>,
cx: &mut Context
) -> Poll<Result<(), <Buffered<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Buffered<S>>,
cx: &mut Context
) -> Poll<Result<(), <Buffered<S> as Sink<Item>>::SinkError>>
impl<S, Item> Sink<Item> for Chunks<S> where
S: Stream + Sink<Item>,
[src]
S: Stream + Sink<Item>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut Chunks<S>>,
cx: &mut Context
) -> Poll<Result<(), <Chunks<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Chunks<S>>,
cx: &mut Context
) -> Poll<Result<(), <Chunks<S> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut Chunks<S>>,
item: Item
) -> Result<(), <Chunks<S> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut Chunks<S>>,
item: Item
) -> Result<(), <Chunks<S> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut Chunks<S>>,
cx: &mut Context
) -> Poll<Result<(), <Chunks<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Chunks<S>>,
cx: &mut Context
) -> Poll<Result<(), <Chunks<S> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut Chunks<S>>,
cx: &mut Context
) -> Poll<Result<(), <Chunks<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Chunks<S>>,
cx: &mut Context
) -> Poll<Result<(), <Chunks<S> as Sink<Item>>::SinkError>>
impl<S, Item> Sink<Item> for Flatten<S> where
S: Stream + Sink<Item>,
<S as Stream>::Item: Stream,
[src]
S: Stream + Sink<Item>,
<S as Stream>::Item: Stream,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut Flatten<S>>,
cx: &mut Context
) -> Poll<Result<(), <Flatten<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Flatten<S>>,
cx: &mut Context
) -> Poll<Result<(), <Flatten<S> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut Flatten<S>>,
item: Item
) -> Result<(), <Flatten<S> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut Flatten<S>>,
item: Item
) -> Result<(), <Flatten<S> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut Flatten<S>>,
cx: &mut Context
) -> Poll<Result<(), <Flatten<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Flatten<S>>,
cx: &mut Context
) -> Poll<Result<(), <Flatten<S> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut Flatten<S>>,
cx: &mut Context
) -> Poll<Result<(), <Flatten<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Flatten<S>>,
cx: &mut Context
) -> Poll<Result<(), <Flatten<S> as Sink<Item>>::SinkError>>
impl<S, Item> Sink<Item> for Fuse<S> where
S: Stream + Sink<Item>,
[src]
S: Stream + Sink<Item>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut Fuse<S>>,
cx: &mut Context
) -> Poll<Result<(), <Fuse<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Fuse<S>>,
cx: &mut Context
) -> Poll<Result<(), <Fuse<S> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut Fuse<S>>,
item: Item
) -> Result<(), <Fuse<S> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut Fuse<S>>,
item: Item
) -> Result<(), <Fuse<S> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut Fuse<S>>,
cx: &mut Context
) -> Poll<Result<(), <Fuse<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Fuse<S>>,
cx: &mut Context
) -> Poll<Result<(), <Fuse<S> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut Fuse<S>>,
cx: &mut Context
) -> Poll<Result<(), <Fuse<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Fuse<S>>,
cx: &mut Context
) -> Poll<Result<(), <Fuse<S> as Sink<Item>>::SinkError>>
impl<S, Item> Sink<Item> for IntoStream<S> where
S: TryStream + Sink<Item>,
[src]
S: TryStream + Sink<Item>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut IntoStream<S>>,
cx: &mut Context
) -> Poll<Result<(), <IntoStream<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut IntoStream<S>>,
cx: &mut Context
) -> Poll<Result<(), <IntoStream<S> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut IntoStream<S>>,
item: Item
) -> Result<(), <IntoStream<S> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut IntoStream<S>>,
item: Item
) -> Result<(), <IntoStream<S> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut IntoStream<S>>,
cx: &mut Context
) -> Poll<Result<(), <IntoStream<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut IntoStream<S>>,
cx: &mut Context
) -> Poll<Result<(), <IntoStream<S> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut IntoStream<S>>,
cx: &mut Context
) -> Poll<Result<(), <IntoStream<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut IntoStream<S>>,
cx: &mut Context
) -> Poll<Result<(), <IntoStream<S> as Sink<Item>>::SinkError>>
impl<S, Item> Sink<Item> for Peekable<S> where
S: Sink<Item> + Stream,
[src]
S: Sink<Item> + Stream,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut Peekable<S>>,
cx: &mut Context
) -> Poll<Result<(), <Peekable<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Peekable<S>>,
cx: &mut Context
) -> Poll<Result<(), <Peekable<S> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut Peekable<S>>,
item: Item
) -> Result<(), <Peekable<S> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut Peekable<S>>,
item: Item
) -> Result<(), <Peekable<S> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut Peekable<S>>,
cx: &mut Context
) -> Poll<Result<(), <Peekable<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Peekable<S>>,
cx: &mut Context
) -> Poll<Result<(), <Peekable<S> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut Peekable<S>>,
cx: &mut Context
) -> Poll<Result<(), <Peekable<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Peekable<S>>,
cx: &mut Context
) -> Poll<Result<(), <Peekable<S> as Sink<Item>>::SinkError>>
impl<S, Item> Sink<Item> for Skip<S> where
S: Stream + Sink<Item>,
[src]
S: Stream + Sink<Item>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut Skip<S>>,
cx: &mut Context
) -> Poll<Result<(), <Skip<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Skip<S>>,
cx: &mut Context
) -> Poll<Result<(), <Skip<S> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut Skip<S>>,
item: Item
) -> Result<(), <Skip<S> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut Skip<S>>,
item: Item
) -> Result<(), <Skip<S> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut Skip<S>>,
cx: &mut Context
) -> Poll<Result<(), <Skip<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Skip<S>>,
cx: &mut Context
) -> Poll<Result<(), <Skip<S> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut Skip<S>>,
cx: &mut Context
) -> Poll<Result<(), <Skip<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Skip<S>>,
cx: &mut Context
) -> Poll<Result<(), <Skip<S> as Sink<Item>>::SinkError>>
impl<S, Item> Sink<Item> for SplitSink<S, Item> where
S: Sink<Item>,
[src]
S: Sink<Item>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut SplitSink<S, Item>>,
cx: &mut Context
) -> Poll<Result<(), <S as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut SplitSink<S, Item>>,
cx: &mut Context
) -> Poll<Result<(), <S as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut SplitSink<S, Item>>,
item: Item
) -> Result<(), <S as Sink<Item>>::SinkError>
[src]
self: Pin<&mut SplitSink<S, Item>>,
item: Item
) -> Result<(), <S as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut SplitSink<S, Item>>,
cx: &mut Context
) -> Poll<Result<(), <S as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut SplitSink<S, Item>>,
cx: &mut Context
) -> Poll<Result<(), <S as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut SplitSink<S, Item>>,
cx: &mut Context
) -> Poll<Result<(), <S as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut SplitSink<S, Item>>,
cx: &mut Context
) -> Poll<Result<(), <S as Sink<Item>>::SinkError>>
impl<S, Item> Sink<Item> for Take<S> where
S: Stream + Sink<Item>,
[src]
S: Stream + Sink<Item>,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut Take<S>>,
cx: &mut Context
) -> Poll<Result<(), <Take<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Take<S>>,
cx: &mut Context
) -> Poll<Result<(), <Take<S> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut Take<S>>,
item: Item
) -> Result<(), <Take<S> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut Take<S>>,
item: Item
) -> Result<(), <Take<S> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut Take<S>>,
cx: &mut Context
) -> Poll<Result<(), <Take<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Take<S>>,
cx: &mut Context
) -> Poll<Result<(), <Take<S> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut Take<S>>,
cx: &mut Context
) -> Poll<Result<(), <Take<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Take<S>>,
cx: &mut Context
) -> Poll<Result<(), <Take<S> as Sink<Item>>::SinkError>>
impl<S, Item> Sink<Item> for TryBufferUnordered<S> where
S: TryStream + Sink<Item>,
<S as TryStream>::Ok: TryFuture,
<<S as TryStream>::Ok as TryFuture>::Error == <S as TryStream>::Error,
[src]
S: TryStream + Sink<Item>,
<S as TryStream>::Ok: TryFuture,
<<S as TryStream>::Ok as TryFuture>::Error == <S as TryStream>::Error,
type SinkError = <S as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut TryBufferUnordered<S>>,
cx: &mut Context
) -> Poll<Result<(), <TryBufferUnordered<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut TryBufferUnordered<S>>,
cx: &mut Context
) -> Poll<Result<(), <TryBufferUnordered<S> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut TryBufferUnordered<S>>,
item: Item
) -> Result<(), <TryBufferUnordered<S> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut TryBufferUnordered<S>>,
item: Item
) -> Result<(), <TryBufferUnordered<S> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut TryBufferUnordered<S>>,
cx: &mut Context
) -> Poll<Result<(), <TryBufferUnordered<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut TryBufferUnordered<S>>,
cx: &mut Context
) -> Poll<Result<(), <TryBufferUnordered<S> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut TryBufferUnordered<S>>,
cx: &mut Context
) -> Poll<Result<(), <TryBufferUnordered<S> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut TryBufferUnordered<S>>,
cx: &mut Context
) -> Poll<Result<(), <TryBufferUnordered<S> as Sink<Item>>::SinkError>>
impl<S, SinkItem> Sink<SinkItem> for Compat01As03Sink<S, SinkItem> where
S: Sink<SinkItem = SinkItem>,
[src]
S: Sink<SinkItem = SinkItem>,
type SinkError = <S as Sink>::SinkError
fn start_send(
self: Pin<&mut Compat01As03Sink<S, SinkItem>>,
item: SinkItem
) -> Result<(), <Compat01As03Sink<S, SinkItem> as Sink<SinkItem>>::SinkError>
[src]
self: Pin<&mut Compat01As03Sink<S, SinkItem>>,
item: SinkItem
) -> Result<(), <Compat01As03Sink<S, SinkItem> as Sink<SinkItem>>::SinkError>
fn poll_ready(
self: Pin<&mut Compat01As03Sink<S, SinkItem>>,
cx: &mut Context
) -> Poll<Result<(), <Compat01As03Sink<S, SinkItem> as Sink<SinkItem>>::SinkError>>
[src]
self: Pin<&mut Compat01As03Sink<S, SinkItem>>,
cx: &mut Context
) -> Poll<Result<(), <Compat01As03Sink<S, SinkItem> as Sink<SinkItem>>::SinkError>>
fn poll_flush(
self: Pin<&mut Compat01As03Sink<S, SinkItem>>,
cx: &mut Context
) -> Poll<Result<(), <Compat01As03Sink<S, SinkItem> as Sink<SinkItem>>::SinkError>>
[src]
self: Pin<&mut Compat01As03Sink<S, SinkItem>>,
cx: &mut Context
) -> Poll<Result<(), <Compat01As03Sink<S, SinkItem> as Sink<SinkItem>>::SinkError>>
fn poll_close(
self: Pin<&mut Compat01As03Sink<S, SinkItem>>,
cx: &mut Context
) -> Poll<Result<(), <Compat01As03Sink<S, SinkItem> as Sink<SinkItem>>::SinkError>>
[src]
self: Pin<&mut Compat01As03Sink<S, SinkItem>>,
cx: &mut Context
) -> Poll<Result<(), <Compat01As03Sink<S, SinkItem> as Sink<SinkItem>>::SinkError>>
impl<Si, F, E, Item> Sink<Item> for SinkMapErr<Si, F> where
F: FnOnce(<Si as Sink<Item>>::SinkError) -> E,
Si: Sink<Item>,
[src]
F: FnOnce(<Si as Sink<Item>>::SinkError) -> E,
Si: Sink<Item>,
type SinkError = E
fn poll_ready(
self: Pin<&mut SinkMapErr<Si, F>>,
cx: &mut Context
) -> Poll<Result<(), <SinkMapErr<Si, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut SinkMapErr<Si, F>>,
cx: &mut Context
) -> Poll<Result<(), <SinkMapErr<Si, F> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut SinkMapErr<Si, F>>,
item: Item
) -> Result<(), <SinkMapErr<Si, F> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut SinkMapErr<Si, F>>,
item: Item
) -> Result<(), <SinkMapErr<Si, F> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut SinkMapErr<Si, F>>,
cx: &mut Context
) -> Poll<Result<(), <SinkMapErr<Si, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut SinkMapErr<Si, F>>,
cx: &mut Context
) -> Poll<Result<(), <SinkMapErr<Si, F> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut SinkMapErr<Si, F>>,
cx: &mut Context
) -> Poll<Result<(), <SinkMapErr<Si, F> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut SinkMapErr<Si, F>>,
cx: &mut Context
) -> Poll<Result<(), <SinkMapErr<Si, F> as Sink<Item>>::SinkError>>
impl<Si, Item> Sink<Item> for Buffer<Si, Item> where
Si: Sink<Item>,
[src]
Si: Sink<Item>,
type SinkError = <Si as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut Buffer<Si, Item>>,
cx: &mut Context
) -> Poll<Result<(), <Buffer<Si, Item> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Buffer<Si, Item>>,
cx: &mut Context
) -> Poll<Result<(), <Buffer<Si, Item> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut Buffer<Si, Item>>,
item: Item
) -> Result<(), <Buffer<Si, Item> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut Buffer<Si, Item>>,
item: Item
) -> Result<(), <Buffer<Si, Item> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut Buffer<Si, Item>>,
cx: &mut Context
) -> Poll<Result<(), <Buffer<Si, Item> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Buffer<Si, Item>>,
cx: &mut Context
) -> Poll<Result<(), <Buffer<Si, Item> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut Buffer<Si, Item>>,
cx: &mut Context
) -> Poll<Result<(), <Buffer<Si, Item> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Buffer<Si, Item>>,
cx: &mut Context
) -> Poll<Result<(), <Buffer<Si, Item> as Sink<Item>>::SinkError>>
impl<Si, Item, E> Sink<Item> for SinkErrInto<Si, Item, E> where
Si: Sink<Item>,
<Si as Sink<Item>>::SinkError: Into<E>,
[src]
Si: Sink<Item>,
<Si as Sink<Item>>::SinkError: Into<E>,
type SinkError = E
fn poll_ready(
self: Pin<&mut SinkErrInto<Si, Item, E>>,
cx: &mut Context
) -> Poll<Result<(), <SinkErrInto<Si, Item, E> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut SinkErrInto<Si, Item, E>>,
cx: &mut Context
) -> Poll<Result<(), <SinkErrInto<Si, Item, E> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut SinkErrInto<Si, Item, E>>,
item: Item
) -> Result<(), <SinkErrInto<Si, Item, E> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut SinkErrInto<Si, Item, E>>,
item: Item
) -> Result<(), <SinkErrInto<Si, Item, E> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut SinkErrInto<Si, Item, E>>,
cx: &mut Context
) -> Poll<Result<(), <SinkErrInto<Si, Item, E> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut SinkErrInto<Si, Item, E>>,
cx: &mut Context
) -> Poll<Result<(), <SinkErrInto<Si, Item, E> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut SinkErrInto<Si, Item, E>>,
cx: &mut Context
) -> Poll<Result<(), <SinkErrInto<Si, Item, E> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut SinkErrInto<Si, Item, E>>,
cx: &mut Context
) -> Poll<Result<(), <SinkErrInto<Si, Item, E> as Sink<Item>>::SinkError>>
impl<Si, Item, U, Fut, F, E> Sink<U> for With<Si, Item, U, Fut, F> where
E: From<<Si as Sink<Item>>::SinkError>,
F: FnMut(U) -> Fut,
Fut: Future<Output = Result<Item, E>>,
Si: Sink<Item>,
[src]
E: From<<Si as Sink<Item>>::SinkError>,
F: FnMut(U) -> Fut,
Fut: Future<Output = Result<Item, E>>,
Si: Sink<Item>,
type SinkError = E
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>>::SinkError>>
[src]
self: Pin<&mut With<Si, Item, U, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <With<Si, Item, U, Fut, F> as Sink<U>>::SinkError>>
fn start_send(
self: Pin<&mut With<Si, Item, U, Fut, F>>,
item: U
) -> Result<(), <With<Si, Item, U, Fut, F> as Sink<U>>::SinkError>
[src]
self: Pin<&mut With<Si, Item, U, Fut, F>>,
item: U
) -> Result<(), <With<Si, Item, U, Fut, F> as Sink<U>>::SinkError>
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>>::SinkError>>
[src]
self: Pin<&mut With<Si, Item, U, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <With<Si, Item, U, Fut, F> as Sink<U>>::SinkError>>
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>>::SinkError>>
[src]
self: Pin<&mut With<Si, Item, U, Fut, F>>,
cx: &mut Context
) -> Poll<Result<(), <With<Si, Item, U, Fut, F> as Sink<U>>::SinkError>>
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>>::SinkError>>,
[src]
F: FnMut(U) -> St,
Si: Sink<Item>,
St: Stream<Item = Result<Item, <Si as Sink<Item>>::SinkError>>,
type SinkError = <Si as Sink<Item>>::SinkError
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>>::SinkError>>
[src]
self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>,
cx: &mut Context
) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::SinkError>>
fn start_send(
self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>,
item: U
) -> Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::SinkError>
[src]
self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>,
item: U
) -> Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::SinkError>
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>>::SinkError>>
[src]
self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>,
cx: &mut Context
) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::SinkError>>
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>>::SinkError>>
[src]
self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>,
cx: &mut Context
) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::SinkError>>
impl<Si1, Si2, Item> Sink<Item> for Fanout<Si1, Si2> where
Item: Clone,
Si1: Sink<Item>,
Si2: Sink<Item, SinkError = <Si1 as Sink<Item>>::SinkError>,
[src]
Item: Clone,
Si1: Sink<Item>,
Si2: Sink<Item, SinkError = <Si1 as Sink<Item>>::SinkError>,
type SinkError = <Si1 as Sink<Item>>::SinkError
fn poll_ready(
self: Pin<&mut Fanout<Si1, Si2>>,
cx: &mut Context
) -> Poll<Result<(), <Fanout<Si1, Si2> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Fanout<Si1, Si2>>,
cx: &mut Context
) -> Poll<Result<(), <Fanout<Si1, Si2> as Sink<Item>>::SinkError>>
fn start_send(
self: Pin<&mut Fanout<Si1, Si2>>,
item: Item
) -> Result<(), <Fanout<Si1, Si2> as Sink<Item>>::SinkError>
[src]
self: Pin<&mut Fanout<Si1, Si2>>,
item: Item
) -> Result<(), <Fanout<Si1, Si2> as Sink<Item>>::SinkError>
fn poll_flush(
self: Pin<&mut Fanout<Si1, Si2>>,
cx: &mut Context
) -> Poll<Result<(), <Fanout<Si1, Si2> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Fanout<Si1, Si2>>,
cx: &mut Context
) -> Poll<Result<(), <Fanout<Si1, Si2> as Sink<Item>>::SinkError>>
fn poll_close(
self: Pin<&mut Fanout<Si1, Si2>>,
cx: &mut Context
) -> Poll<Result<(), <Fanout<Si1, Si2> as Sink<Item>>::SinkError>>
[src]
self: Pin<&mut Fanout<Si1, Si2>>,
cx: &mut Context
) -> Poll<Result<(), <Fanout<Si1, Si2> as Sink<Item>>::SinkError>>
impl<T> Sink<T> for Sender<T>
[src]
type SinkError = SendError
fn poll_ready(
self: Pin<&mut Sender<T>>,
cx: &mut Context
) -> Poll<Result<(), <Sender<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut Sender<T>>,
cx: &mut Context
) -> Poll<Result<(), <Sender<T> as Sink<T>>::SinkError>>
fn start_send(
self: Pin<&mut Sender<T>>,
msg: T
) -> Result<(), <Sender<T> as Sink<T>>::SinkError>
[src]
self: Pin<&mut Sender<T>>,
msg: T
) -> Result<(), <Sender<T> as Sink<T>>::SinkError>
fn poll_flush(
self: Pin<&mut Sender<T>>,
&mut Context
) -> Poll<Result<(), <Sender<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut Sender<T>>,
&mut Context
) -> Poll<Result<(), <Sender<T> as Sink<T>>::SinkError>>
fn poll_close(
self: Pin<&mut Sender<T>>,
&mut Context
) -> Poll<Result<(), <Sender<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut Sender<T>>,
&mut Context
) -> Poll<Result<(), <Sender<T> as Sink<T>>::SinkError>>
impl<T> Sink<T> for UnboundedSender<T>
[src]
type SinkError = SendError
fn poll_ready(
self: Pin<&mut UnboundedSender<T>>,
cx: &mut Context
) -> Poll<Result<(), <UnboundedSender<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut UnboundedSender<T>>,
cx: &mut Context
) -> Poll<Result<(), <UnboundedSender<T> as Sink<T>>::SinkError>>
fn start_send(
self: Pin<&mut UnboundedSender<T>>,
msg: T
) -> Result<(), <UnboundedSender<T> as Sink<T>>::SinkError>
[src]
self: Pin<&mut UnboundedSender<T>>,
msg: T
) -> Result<(), <UnboundedSender<T> as Sink<T>>::SinkError>
fn poll_flush(
self: Pin<&mut UnboundedSender<T>>,
&mut Context
) -> Poll<Result<(), <UnboundedSender<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut UnboundedSender<T>>,
&mut Context
) -> Poll<Result<(), <UnboundedSender<T> as Sink<T>>::SinkError>>
fn poll_close(
self: Pin<&mut UnboundedSender<T>>,
&mut Context
) -> Poll<Result<(), <UnboundedSender<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut UnboundedSender<T>>,
&mut Context
) -> Poll<Result<(), <UnboundedSender<T> as Sink<T>>::SinkError>>
impl<T> Sink<T> for Drain<T>
[src]
type SinkError = DrainError
fn poll_ready(
self: Pin<&mut Drain<T>>,
_cx: &mut Context
) -> Poll<Result<(), <Drain<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut Drain<T>>,
_cx: &mut Context
) -> Poll<Result<(), <Drain<T> as Sink<T>>::SinkError>>
fn start_send(
self: Pin<&mut Drain<T>>,
_item: T
) -> Result<(), <Drain<T> as Sink<T>>::SinkError>
[src]
self: Pin<&mut Drain<T>>,
_item: T
) -> Result<(), <Drain<T> as Sink<T>>::SinkError>
fn poll_flush(
self: Pin<&mut Drain<T>>,
_cx: &mut Context
) -> Poll<Result<(), <Drain<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut Drain<T>>,
_cx: &mut Context
) -> Poll<Result<(), <Drain<T> as Sink<T>>::SinkError>>
fn poll_close(
self: Pin<&mut Drain<T>>,
_cx: &mut Context
) -> Poll<Result<(), <Drain<T> as Sink<T>>::SinkError>>
[src]
self: Pin<&mut Drain<T>>,
_cx: &mut Context
) -> Poll<Result<(), <Drain<T> as Sink<T>>::SinkError>>