Trait futures_util::sink::Sink [−][src]
#[must_use = "sinks do nothing unless polled"] pub trait Sink<Item> { type Error; pub fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>; pub fn start_send(
self: Pin<&mut Self>,
item: Item
) -> Result<(), Self::Error>; pub fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>; pub fn poll_close(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>; }
A Sink
is a value into which other values can be sent, asynchronously.
Basic examples of sinks include the sending side of:
- Channels
- Sockets
- Pipes
In addition to such “primitive” sinks, it’s typical to layer additional functionality, such as buffering, on top of an existing sink.
Sending to a sink is “asynchronous” in the sense that the value may not be sent in its entirety immediately. Instead, values are sent in a two-phase way: first by initiating a send, and then by polling for completion. This two-phase setup is analogous to buffered writing in synchronous code, where writes often succeed immediately, but internally are buffered and are actually written only upon flushing.
In addition, the Sink
may be full, in which case it is not even possible
to start the sending process.
As with Future
and Stream
, the Sink
trait is built from a few core
required methods, and a host of default methods for working in a
higher-level way. The Sink::send_all
combinator is of particular
importance: you can use it to send an entire stream to a sink, which is
the simplest way to ultimately consume a stream.
Associated Types
Loading content...Required methods
pub fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
Attempts to prepare the Sink
to receive a value.
This method must be called and return Poll::Ready(Ok(()))
prior to
each call to start_send
.
This method returns Poll::Ready
once the underlying sink is ready to
receive data. If this method returns Poll::Pending
, the current task
is registered to be notified (via cx.waker().wake_by_ref()
) when poll_ready
should be called again.
In most cases, if the sink encounters an error, the sink will permanently be unable to receive items.
pub fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
Begin the process of sending a value to the sink.
Each call to this function must be preceded by a successful call to
poll_ready
which returned Poll::Ready(Ok(()))
.
As the name suggests, this method only begins the process of sending
the item. If the sink employs buffering, the item isn’t fully processed
until the buffer is fully flushed. Since sinks are designed to work with
asynchronous I/O, the process of actually writing out the data to an
underlying object takes place asynchronously. You must use
poll_flush
or poll_close
in order to guarantee completion of a
send.
Implementations of poll_ready
and start_send
will usually involve
flushing behind the scenes in order to make room for new messages.
It is only necessary to call poll_flush
if you need to guarantee that
all of the items placed into the Sink
have been sent.
In most cases, if the sink encounters an error, the sink will permanently be unable to receive items.
pub fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
Flush any remaining output from this sink.
Returns Poll::Ready(Ok(()))
when no buffered items remain. If this
value is returned then it is guaranteed that all previous values sent
via start_send
have been flushed.
Returns Poll::Pending
if there is more work left to do, in which
case the current task is scheduled (via cx.waker().wake_by_ref()
) to wake up when
poll_flush
should be called again.
In most cases, if the sink encounters an error, the sink will permanently be unable to receive items.
pub fn poll_close(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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.
Implementations on Foreign Types
impl<T> Sink<T> for Vec<T, Global>
[src]
impl<T> Sink<T> for Vec<T, Global>
[src]type Error = Infallible
pub fn poll_ready(
self: Pin<&mut Vec<T, Global>>,
&mut Context<'_>
) -> Poll<Result<(), <Vec<T, Global> as Sink<T>>::Error>>
[src]
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>
[src]
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>>
[src]
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>>
[src]
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,
[src]
impl<S, Item> Sink<Item> for Box<S, Global> where
S: Sink<Item> + Unpin + ?Sized,
[src]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>>
[src]
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>
[src]
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>>
[src]
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>>
[src]
self: Pin<&mut Box<S, Global>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Box<S, Global> as Sink<Item>>::Error>>
impl<'_, S, Item> Sink<Item> for &'_ mut S where
S: Sink<Item> + Unpin + ?Sized,
[src]
impl<'_, S, Item> Sink<Item> for &'_ mut S where
S: Sink<Item> + Unpin + ?Sized,
[src]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>>
[src]
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>
[src]
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>>
[src]
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>>
[src]
self: Pin<&mut &'_ mut S>,
cx: &mut Context<'_>
) -> Poll<Result<(), <&'_ mut S as Sink<Item>>::Error>>
impl<P, Item> Sink<Item> for Pin<P> where
P: DerefMut + Unpin,
<P as Deref>::Target: Sink<Item>,
[src]
impl<P, Item> Sink<Item> for Pin<P> where
P: DerefMut + Unpin,
<P as Deref>::Target: Sink<Item>,
[src]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>>
[src]
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>
[src]
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>>
[src]
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>>
[src]
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Pin<P> as Sink<Item>>::Error>>
impl<T> Sink<T> for VecDeque<T>
[src]
impl<T> Sink<T> for VecDeque<T>
[src]type Error = Infallible
pub fn poll_ready(
self: Pin<&mut VecDeque<T>>,
&mut Context<'_>
) -> Poll<Result<(), <VecDeque<T> as Sink<T>>::Error>>
[src]
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>
[src]
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>>
[src]
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>>
[src]
self: Pin<&mut VecDeque<T>>,
&mut Context<'_>
) -> Poll<Result<(), <VecDeque<T> as Sink<T>>::Error>>
impl<T> Sink<T> for Sender<T>
[src]
impl<T> Sink<T> for Sender<T>
[src]type Error = SendError
pub fn poll_ready(
self: Pin<&mut Sender<T>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Sender<T> as Sink<T>>::Error>>
[src]
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>
[src]
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>>
[src]
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>>
[src]
self: Pin<&mut Sender<T>>,
&mut Context<'_>
) -> Poll<Result<(), <Sender<T> as Sink<T>>::Error>>
impl<'_, T> Sink<T> for &'_ UnboundedSender<T>
[src]
impl<'_, T> Sink<T> for &'_ UnboundedSender<T>
[src]type Error = SendError
pub fn poll_ready(
self: Pin<&mut &'_ UnboundedSender<T>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <&'_ UnboundedSender<T> as Sink<T>>::Error>>
[src]
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>
[src]
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>>
[src]
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>>
[src]
self: Pin<&mut &'_ UnboundedSender<T>>,
&mut Context<'_>
) -> Poll<Result<(), <&'_ UnboundedSender<T> as Sink<T>>::Error>>
impl<T> Sink<T> for UnboundedSender<T>
[src]
impl<T> Sink<T> for UnboundedSender<T>
[src]type Error = SendError
pub fn poll_ready(
self: Pin<&mut UnboundedSender<T>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <UnboundedSender<T> as Sink<T>>::Error>>
[src]
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>
[src]
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>>
[src]
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>>
[src]
self: Pin<&mut UnboundedSender<T>>,
&mut Context<'_>
) -> Poll<Result<(), <UnboundedSender<T> as Sink<T>>::Error>>
Implementors
impl<A, B, Item> Sink<Item> for Either<A, B> where
A: Sink<Item>,
B: Sink<Item, Error = A::Error>,
[src]
impl<A, B, Item> Sink<Item> for Either<A, B> where
A: Sink<Item>,
B: Sink<Item, Error = A::Error>,
[src]type Error = A::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Fut, F, Item> Sink<Item> for AndThen<S, Fut, F> where
S: Sink<Item>,
[src]
impl<S, Fut, F, Item> Sink<Item> for AndThen<S, Fut, F> where
S: Sink<Item>,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Fut, F, Item> Sink<Item> for Filter<S, Fut, F> where
S: Stream + Sink<Item>,
F: FnMut(&S::Item) -> Fut,
Fut: Future<Output = bool>,
[src]
impl<S, Fut, F, Item> Sink<Item> for Filter<S, Fut, F> where
S: Stream + Sink<Item>,
F: FnMut(&S::Item) -> Fut,
Fut: Future<Output = bool>,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Fut, F, Item> Sink<Item> for FilterMap<S, Fut, F> where
S: Stream + Sink<Item>,
F: FnMut1<S::Item, Output = Fut>,
Fut: Future,
[src]
impl<S, Fut, F, Item> Sink<Item> for FilterMap<S, Fut, F> where
S: Stream + Sink<Item>,
F: FnMut1<S::Item, Output = Fut>,
Fut: Future,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Fut, F, Item> Sink<Item> for OrElse<S, Fut, F> where
S: Sink<Item>,
[src]
impl<S, Fut, F, Item> Sink<Item> for OrElse<S, Fut, F> where
S: Sink<Item>,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Fut, F, Item> Sink<Item> for Scan<S, S, Fut, F> where
S: Stream + Sink<Item>,
[src]
impl<S, Fut, F, Item> Sink<Item> for Scan<S, S, Fut, F> where
S: Stream + Sink<Item>,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Fut, F, Item> Sink<Item> for SkipWhile<S, Fut, F> where
S: Stream + Sink<Item>,
F: FnMut(&S::Item) -> Fut,
Fut: Future<Output = bool>,
[src]
impl<S, Fut, F, Item> Sink<Item> for SkipWhile<S, Fut, F> where
S: Stream + Sink<Item>,
F: FnMut(&S::Item) -> Fut,
Fut: Future<Output = bool>,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Fut, F, Item> Sink<Item> for TakeWhile<S, Fut, F> where
S: Stream + Sink<Item>,
[src]
impl<S, Fut, F, Item> Sink<Item> for TakeWhile<S, Fut, F> where
S: Stream + Sink<Item>,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Fut, F, Item> Sink<Item> for Then<S, Fut, F> where
S: Sink<Item>,
[src]
impl<S, Fut, F, Item> Sink<Item> for Then<S, Fut, F> where
S: Sink<Item>,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Fut, F, Item> Sink<Item> for TryFilterMap<S, Fut, F> where
S: Sink<Item>,
[src]
impl<S, Fut, F, Item> Sink<Item> for TryFilterMap<S, Fut, F> where
S: Sink<Item>,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Fut, F, Item, E> Sink<Item> for TryFilter<S, Fut, F> where
S: TryStream + Sink<Item, Error = E>,
[src]
impl<S, Fut, F, Item, E> Sink<Item> for TryFilter<S, Fut, F> where
S: TryStream + Sink<Item, Error = E>,
[src]type Error = E
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Fut, F, Item, E> Sink<Item> for TrySkipWhile<S, Fut, F> where
S: TryStream + Sink<Item, Error = E>,
[src]
impl<S, Fut, F, Item, E> Sink<Item> for TrySkipWhile<S, Fut, F> where
S: TryStream + Sink<Item, Error = E>,
[src]type Error = E
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Fut, F, Item, E> Sink<Item> for TryTakeWhile<S, Fut, F> where
S: TryStream + Sink<Item, Error = E>,
[src]
impl<S, Fut, F, Item, E> Sink<Item> for TryTakeWhile<S, Fut, F> where
S: TryStream + Sink<Item, Error = E>,
[src]type Error = E
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Fut, Item> Sink<Item> for TakeUntil<S, Fut> where
S: Stream + Sink<Item>,
Fut: Future,
[src]
impl<S, Fut, Item> Sink<Item> for TakeUntil<S, Fut> where
S: Stream + Sink<Item>,
Fut: Future,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Item> Sink<Item> for BufferUnordered<S> where
S: Stream + Sink<Item>,
S::Item: Future,
[src]
impl<S, Item> Sink<Item> for BufferUnordered<S> where
S: Stream + Sink<Item>,
S::Item: Future,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Item> Sink<Item> for Buffered<S> where
S: Stream + Sink<Item>,
S::Item: Future,
[src]
impl<S, Item> Sink<Item> for Buffered<S> where
S: Stream + Sink<Item>,
S::Item: Future,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Item> Sink<Item> for Chunks<S> where
S: Stream + Sink<Item>,
[src]
impl<S, Item> Sink<Item> for Chunks<S> where
S: Stream + Sink<Item>,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Item> Sink<Item> for Enumerate<S> where
S: Stream + Sink<Item>,
[src]
impl<S, Item> Sink<Item> for Enumerate<S> where
S: Stream + Sink<Item>,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Item> Sink<Item> for Peekable<S> where
S: Sink<Item> + Stream,
[src]
impl<S, Item> Sink<Item> for Peekable<S> where
S: Sink<Item> + Stream,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Item> Sink<Item> for ReadyChunks<S> where
S: Stream + Sink<Item>,
[src]
impl<S, Item> Sink<Item> for ReadyChunks<S> where
S: Stream + Sink<Item>,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Item> Sink<Item> for Skip<S> where
S: Stream + Sink<Item>,
[src]
impl<S, Item> Sink<Item> for Skip<S> where
S: Stream + Sink<Item>,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Item> Sink<Item> for Take<S> where
S: Stream + Sink<Item>,
[src]
impl<S, Item> Sink<Item> for Take<S> where
S: Stream + Sink<Item>,
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Item> Sink<Item> for TryFlatten<S> where
S: TryStream + Sink<Item>,
[src]
impl<S, Item> Sink<Item> for TryFlatten<S> where
S: TryStream + Sink<Item>,
[src]type Error = <S as Sink<Item>>::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Item, E> Sink<Item> for TryBufferUnordered<S> where
S: TryStream + Sink<Item, Error = E>,
S::Ok: TryFuture<Error = E>,
[src]
impl<S, Item, E> Sink<Item> for TryBufferUnordered<S> where
S: TryStream + Sink<Item, Error = E>,
S::Ok: TryFuture<Error = E>,
[src]type Error = E
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S, Item, E> Sink<Item> for TryBuffered<S> where
S: TryStream + Sink<Item, Error = E>,
S::Ok: TryFuture<Error = E>,
[src]
impl<S, Item, E> Sink<Item> for TryBuffered<S> where
S: TryStream + Sink<Item, Error = E>,
S::Ok: TryFuture<Error = E>,
[src]type Error = E
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S: Stream + Sink<Item>, Item> Sink<Item> for Fuse<S>
[src]
impl<S: Stream + Sink<Item>, Item> Sink<Item> for Fuse<S>
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S: Sink<Item>, Item> Sink<Item> for IntoStream<S>
[src]
impl<S: Sink<Item>, Item> Sink<Item> for IntoStream<S>
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<S: Sink<Item>, Item> Sink<Item> for SplitSink<S, Item>
[src]
impl<S: Sink<Item>, Item> Sink<Item> for SplitSink<S, Item>
[src]type Error = S::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), S::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), S::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), S::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), S::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), S::Error>>
fn poll_close(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), S::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), S::Error>>
impl<Si1, Si2, Item> Sink<Item> for Fanout<Si1, Si2> where
Si1: Sink<Item>,
Item: Clone,
Si2: Sink<Item, Error = Si1::Error>,
[src]
impl<Si1, Si2, Item> Sink<Item> for Fanout<Si1, Si2> where
Si1: Sink<Item>,
Item: Clone,
Si2: Sink<Item, Error = Si1::Error>,
[src]type Error = Si1::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<Si, F, E, Item> Sink<Item> for SinkMapErr<Si, F> where
Si: Sink<Item>,
F: FnOnce(Si::Error) -> E,
[src]
impl<Si, F, E, Item> Sink<Item> for SinkMapErr<Si, F> where
Si: Sink<Item>,
F: FnOnce(Si::Error) -> E,
[src]type Error = E
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<Si, Item, E> Sink<Item> for SinkErrInto<Si, Item, E> where
Si: Sink<Item>,
Si::Error: Into<E>,
[src]
impl<Si, Item, E> Sink<Item> for SinkErrInto<Si, Item, E> where
Si: Sink<Item>,
Si::Error: Into<E>,
[src]type Error = E
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<Si, Item, U, Fut, F, E> Sink<U> for With<Si, Item, U, Fut, F> where
Si: Sink<Item>,
F: FnMut(U) -> Fut,
Fut: Future<Output = Result<Item, E>>,
E: From<Si::Error>,
[src]
impl<Si, Item, U, Fut, F, E> Sink<U> for With<Si, Item, U, Fut, F> where
Si: Sink<Item>,
F: FnMut(U) -> Fut,
Fut: Future<Output = Result<Item, E>>,
E: From<Si::Error>,
[src]type Error = E
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: U) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<Si, Item, U, St, F> Sink<U> for WithFlatMap<Si, Item, U, St, F> where
Si: Sink<Item>,
F: FnMut(U) -> St,
St: Stream<Item = Result<Item, Si::Error>>,
[src]
impl<Si, Item, U, St, F> Sink<U> for WithFlatMap<Si, Item, U, St, F> where
Si: Sink<Item>,
F: FnMut(U) -> St,
St: Stream<Item = Result<Item, Si::Error>>,
[src]type Error = Si::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: U) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<Si: Sink<Item>, Item> Sink<Item> for Buffer<Si, Item>
[src]
impl<Si: Sink<Item>, Item> Sink<Item> for Buffer<Si, Item>
[src]type Error = Si::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<St, F, Item> Sink<Item> for Map<St, F> where
St: Stream + Sink<Item>,
F: FnMut1<St::Item>,
[src]
impl<St, F, Item> Sink<Item> for Map<St, F> where
St: Stream + Sink<Item>,
F: FnMut1<St::Item>,
[src]type Error = St::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<T> Sink<T> for Drain<T>
[src]
impl<T> Sink<T> for Drain<T>
[src]type Error = Never
fn poll_ready(
self: Pin<&mut Self>,
_cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
_cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, _item: T) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
_cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
_cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<T, F, R, Item, E> Sink<Item> for Unfold<T, F, R> where
F: FnMut(T, Item) -> R,
R: Future<Output = Result<T, E>>,
[src]
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>>,
[src]type Error = E
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<W: AsyncWrite, Item: AsRef<[u8]>> Sink<Item> for IntoSink<W, Item>
[src]
impl<W: AsyncWrite, Item: AsRef<[u8]>> Sink<Item> for IntoSink<W, Item>
[src]type Error = Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<_Item, F> Sink<_Item> for FlattenStream<F> where
Flatten<F, <F as Future>::Output>: Sink<_Item>,
F: Future,
[src]
impl<_Item, F> Sink<_Item> for FlattenStream<F> where
Flatten<F, <F as Future>::Output>: Sink<_Item>,
F: Future,
[src]type Error = <Flatten<F, <F as Future>::Output> as Sink<_Item>>::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<_Item, Fut> Sink<_Item> for TryFlattenStream<Fut> where
TryFlatten<Fut, Fut::Ok>: Sink<_Item>,
Fut: TryFuture,
[src]
impl<_Item, Fut> Sink<_Item> for TryFlattenStream<Fut> where
TryFlatten<Fut, Fut::Ok>: Sink<_Item>,
Fut: TryFuture,
[src]type Error = <TryFlatten<Fut, Fut::Ok> as Sink<_Item>>::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<_Item, Fut, Si> Sink<_Item> for FlattenSink<Fut, Si> where
TryFlatten<Fut, Si>: Sink<_Item>,
[src]
impl<_Item, Fut, Si> Sink<_Item> for FlattenSink<Fut, Si> where
TryFlatten<Fut, Si>: Sink<_Item>,
[src]type Error = <TryFlatten<Fut, Si> as Sink<_Item>>::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<_Item, St> Sink<_Item> for Flatten<St> where
Flatten<St, St::Item>: Sink<_Item>,
St: Stream,
[src]
impl<_Item, St> Sink<_Item> for Flatten<St> where
Flatten<St, St::Item>: Sink<_Item>,
St: Stream,
[src]type Error = <Flatten<St, St::Item> as Sink<_Item>>::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<_Item, St, E> Sink<_Item> for ErrInto<St, E> where
MapErr<St, IntoFn<E>>: Sink<_Item>,
[src]
impl<_Item, St, E> Sink<_Item> for ErrInto<St, E> where
MapErr<St, IntoFn<E>>: Sink<_Item>,
[src]type Error = <MapErr<St, IntoFn<E>> as Sink<_Item>>::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<_Item, St, F> Sink<_Item> for Inspect<St, F> where
Map<St, InspectFn<F>>: Sink<_Item>,
[src]
impl<_Item, St, F> Sink<_Item> for Inspect<St, F> where
Map<St, InspectFn<F>>: Sink<_Item>,
[src]type Error = <Map<St, InspectFn<F>> as Sink<_Item>>::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<_Item, St, F> Sink<_Item> for InspectErr<St, F> where
Inspect<IntoStream<St>, InspectErrFn<F>>: Sink<_Item>,
[src]
impl<_Item, St, F> Sink<_Item> for InspectErr<St, F> where
Inspect<IntoStream<St>, InspectErrFn<F>>: Sink<_Item>,
[src]type Error = <Inspect<IntoStream<St>, InspectErrFn<F>> as Sink<_Item>>::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<_Item, St, F> Sink<_Item> for InspectOk<St, F> where
Inspect<IntoStream<St>, InspectOkFn<F>>: Sink<_Item>,
[src]
impl<_Item, St, F> Sink<_Item> for InspectOk<St, F> where
Inspect<IntoStream<St>, InspectOkFn<F>>: Sink<_Item>,
[src]type Error = <Inspect<IntoStream<St>, InspectOkFn<F>> as Sink<_Item>>::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<_Item, St, F> Sink<_Item> for MapErr<St, F> where
Map<IntoStream<St>, MapErrFn<F>>: Sink<_Item>,
[src]
impl<_Item, St, F> Sink<_Item> for MapErr<St, F> where
Map<IntoStream<St>, MapErrFn<F>>: Sink<_Item>,
[src]type Error = <Map<IntoStream<St>, MapErrFn<F>> as Sink<_Item>>::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<_Item, St, F> Sink<_Item> for MapOk<St, F> where
Map<IntoStream<St>, MapOkFn<F>>: Sink<_Item>,
[src]
impl<_Item, St, F> Sink<_Item> for MapOk<St, F> where
Map<IntoStream<St>, MapOkFn<F>>: Sink<_Item>,
[src]type Error = <Map<IntoStream<St>, MapOkFn<F>> as Sink<_Item>>::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
impl<_Item, St, U, F> Sink<_Item> for FlatMap<St, U, F> where
Flatten<Map<St, F>, U>: Sink<_Item>,
[src]
impl<_Item, St, U, F> Sink<_Item> for FlatMap<St, U, F> where
Flatten<Map<St, F>, U>: Sink<_Item>,
[src]type Error = <Flatten<Map<St, F>, U> as Sink<_Item>>::Error
fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: _Item) -> Result<(), Self::Error>
[src]
fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>
[src]
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>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>