[−][src]Struct futures::sink::WithFlatMap
Sink for the with_flat_map method.
Methods
impl<Si, Item, U, St, F> WithFlatMap<Si, Item, U, St, F> where
F: FnMut(U) -> St,
Si: Sink<Item>,
St: Stream<Item = Result<Item, <Si as Sink<Item>>::Error>>, [src]
F: FnMut(U) -> St,
Si: Sink<Item>,
St: Stream<Item = Result<Item, <Si as Sink<Item>>::Error>>,
ⓘImportant traits for &'_ mut Fpub fn get_ref(&self) -> &Si[src]
ⓘImportant traits for &'_ mut F
Get a shared reference to the inner sink.
ⓘImportant traits for &'_ mut Fpub fn get_mut(&mut self) -> &mut Si[src]
ⓘImportant traits for &'_ mut F
Get a mutable reference to the inner sink.
ⓘImportant traits for Pin<P>pub fn get_pin_mut(
self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>
) -> Pin<&mut Si>[src]
ⓘImportant traits for Pin<P>
self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>
) -> Pin<&mut Si>
Get a pinned mutable reference to the inner sink.
pub fn into_inner(self) -> Si[src]
Consumes this combinator, returning the underlying sink.
Note that this may discard intermediate state of this combinator, so care should be taken to avoid losing resources when this is called.
Trait Implementations
impl<Si, Item, U, St, F> Unpin for WithFlatMap<Si, Item, U, St, F> where
Si: Unpin,
St: Unpin, [src]
Si: Unpin,
St: Unpin,
impl<Si, Item, U, St, F> Sink<U> for WithFlatMap<Si, Item, U, St, F> where
F: FnMut(U) -> St,
Si: Sink<Item>,
St: Stream<Item = Result<Item, <Si as Sink<Item>>::Error>>, [src]
F: FnMut(U) -> St,
Si: Sink<Item>,
St: Stream<Item = Result<Item, <Si as Sink<Item>>::Error>>,
type Error = <Si as Sink<Item>>::Error
The type of value produced by the sink when an error occurs.
fn poll_ready(
self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>,
cx: &mut Context
) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>>[src]
self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>,
cx: &mut Context
) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>>
fn start_send(
self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>,
item: U
) -> Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>[src]
self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>,
item: U
) -> Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>
fn poll_flush(
self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>,
cx: &mut Context
) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>>[src]
self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>,
cx: &mut Context
) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>>
fn poll_close(
self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>,
cx: &mut Context
) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>>[src]
self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>,
cx: &mut Context
) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>>
impl<Si, Item, U, St, F> Debug for WithFlatMap<Si, Item, U, St, F> where
Item: Debug,
Si: Debug,
St: Debug, [src]
Item: Debug,
Si: Debug,
St: Debug,
impl<S, Item, U, St, F> Stream for WithFlatMap<S, Item, U, St, F> where
F: FnMut(U) -> St,
S: Stream + Sink<Item>,
St: Stream<Item = Result<Item, <S as Sink<Item>>::Error>>, [src]
F: FnMut(U) -> St,
S: Stream + Sink<Item>,
St: Stream<Item = Result<Item, <S as Sink<Item>>::Error>>,
type Item = <S as Stream>::Item
Values yielded by the stream.
fn poll_next(
self: Pin<&mut WithFlatMap<S, Item, U, St, F>>,
cx: &mut Context
) -> Poll<Option<<S as Stream>::Item>>[src]
self: Pin<&mut WithFlatMap<S, Item, U, St, F>>,
cx: &mut Context
) -> Poll<Option<<S as Stream>::Item>>
fn size_hint(&self) -> (usize, Option<usize>)[src]
impl<S, Item, U, St, F> FusedStream for WithFlatMap<S, Item, U, St, F> where
F: FnMut(U) -> St,
S: FusedStream + Sink<Item>,
St: Stream<Item = Result<Item, <S as Sink<Item>>::Error>>, [src]
F: FnMut(U) -> St,
S: FusedStream + Sink<Item>,
St: Stream<Item = Result<Item, <S as Sink<Item>>::Error>>,
fn is_terminated(&self) -> bool[src]
Auto Trait Implementations
impl<Si, Item, U, St, F> Send for WithFlatMap<Si, Item, U, St, F> where
F: Send,
Item: Send,
Si: Send,
St: Send,
F: Send,
Item: Send,
Si: Send,
St: Send,
impl<Si, Item, U, St, F> Sync for WithFlatMap<Si, Item, U, St, F> where
F: Sync,
Item: Sync,
Si: Sync,
St: Sync,
F: Sync,
Item: Sync,
Si: Sync,
St: Sync,
impl<Si, Item, U, St, F> UnwindSafe for WithFlatMap<Si, Item, U, St, F> where
F: UnwindSafe,
Item: UnwindSafe,
Si: UnwindSafe,
St: UnwindSafe,
F: UnwindSafe,
Item: UnwindSafe,
Si: UnwindSafe,
St: UnwindSafe,
impl<Si, Item, U, St, F> RefUnwindSafe for WithFlatMap<Si, Item, U, St, F> where
F: RefUnwindSafe,
Item: RefUnwindSafe,
Si: RefUnwindSafe,
St: RefUnwindSafe,
F: RefUnwindSafe,
Item: RefUnwindSafe,
Si: RefUnwindSafe,
St: RefUnwindSafe,
Blanket Implementations
impl<T, U> Into<U> for T where
U: From<T>, [src]
U: From<T>,
impl<T> From<T> for T[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]
impl<T> Borrow<T> for T where
T: ?Sized, [src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized, [src]
T: ?Sized,
ⓘImportant traits for &'_ mut Ffn borrow_mut(&mut self) -> &mut T[src]
ⓘImportant traits for &'_ mut F
impl<T> Any for T where
T: 'static + ?Sized, [src]
T: 'static + ?Sized,
impl<S, T, E> TryStream for S where
S: Stream<Item = Result<T, E>> + ?Sized, [src]
S: Stream<Item = Result<T, E>> + ?Sized,
type Ok = T
The type of successful values yielded by this future
type Error = E
The type of failures yielded by this future
fn try_poll_next(
self: Pin<&mut S>,
cx: &mut Context
) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>[src]
self: Pin<&mut S>,
cx: &mut Context
) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>
impl<T> StreamExt for T where
T: Stream + ?Sized, [src]
T: Stream + ?Sized,
ⓘImportant traits for Next<'_, St>fn next(&mut self) -> Next<Self> where
Self: Unpin, [src]
ⓘImportant traits for Next<'_, St>
Self: Unpin,
ⓘImportant traits for StreamFuture<St>fn into_future(self) -> StreamFuture<Self> where
Self: Unpin, [src]
ⓘImportant traits for StreamFuture<St>
Self: Unpin,
fn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T, [src]
F: FnMut(Self::Item) -> T,
fn enumerate(self) -> Enumerate<Self>[src]
fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>, [src]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>, [src]
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>,
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future, [src]
F: FnMut(Self::Item) -> Fut,
Fut: Future,
ⓘImportant traits for Collect<St, C>fn collect<C>(self) -> Collect<Self, C> where
C: Default + Extend<Self::Item>, [src]
ⓘImportant traits for Collect<St, C>
C: Default + Extend<Self::Item>,
ⓘImportant traits for Concat<St>fn concat(self) -> Concat<Self> where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default, [src]
ⓘImportant traits for Concat<St>
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
ⓘImportant traits for Fold<St, Fut, T, F>fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F> where
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>, [src]
ⓘImportant traits for Fold<St, Fut, T, F>
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>,
fn flatten(self) -> Flatten<Self> where
Self::Item: Stream, [src]
Self::Item: Stream,
fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>, [src]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>, [src]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
ⓘImportant traits for ForEach<St, Fut, F>fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>, [src]
ⓘImportant traits for ForEach<St, Fut, F>
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
ⓘImportant traits for ForEachConcurrent<St, Fut, F>fn for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>, [src]
ⓘImportant traits for ForEachConcurrent<St, Fut, F>
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
fn take(self, n: usize) -> Take<Self>[src]
fn skip(self, n: usize) -> Skip<Self>[src]
fn fuse(self) -> Fuse<Self>[src]
ⓘImportant traits for &'_ mut Ffn by_ref(&mut self) -> &mut Self[src]
ⓘImportant traits for &'_ mut F
fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe, [src]
Self: UnwindSafe,
ⓘImportant traits for Pin<P>fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send>> where
Self: Send + 'a, [src]
ⓘImportant traits for Pin<P>
Self: Send + 'a,
ⓘImportant traits for Pin<P>fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>> where
Self: 'a, [src]
ⓘImportant traits for Pin<P>
Self: 'a,
fn buffered(self, n: usize) -> Buffered<Self> where
Self::Item: Future, [src]
Self::Item: Future,
fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where
Self::Item: Future, [src]
Self::Item: Future,
fn zip<St>(self, other: St) -> Zip<Self, St> where
St: Stream, [src]
St: Stream,
fn chain<St>(self, other: St) -> Chain<Self, St> where
St: Stream<Item = Self::Item>, [src]
St: Stream<Item = Self::Item>,
fn peekable(self) -> Peekable<Self>[src]
fn chunks(self, capacity: usize) -> Chunks<Self>[src]
ⓘImportant traits for Forward<St, Si>fn forward<S>(self, sink: S) -> Forward<Self, S> where
S: Sink<Self::Ok>,
Self: TryStream<Error = <S as Sink<Self::Ok>>::Error>, [src]
ⓘImportant traits for Forward<St, Si>
S: Sink<Self::Ok>,
Self: TryStream<Error = <S as Sink<Self::Ok>>::Error>,
fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where
Self: Sink<Item>, [src]
Self: Sink<Item>,
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item), [src]
F: FnMut(&Self::Item),
ⓘImportant traits for Either<A, B>fn left_stream<B>(self) -> Either<Self, B> where
B: Stream<Item = Self::Item>, [src]
ⓘImportant traits for Either<A, B>
B: Stream<Item = Self::Item>,
ⓘImportant traits for Either<A, B>fn right_stream<B>(self) -> Either<B, Self> where
B: Stream<Item = Self::Item>, [src]
ⓘImportant traits for Either<A, B>
B: Stream<Item = Self::Item>,
fn poll_next_unpin(&mut self, cx: &mut Context) -> Poll<Option<Self::Item>> where
Self: Unpin, [src]
Self: Unpin,
ⓘImportant traits for SelectNextSome<'_, St>fn select_next_some(&mut self) -> SelectNextSome<Self> where
Self: Unpin + FusedStream, [src]
ⓘImportant traits for SelectNextSome<'_, St>
Self: Unpin + FusedStream,
impl<S> TryStreamExt for S where
S: TryStream + ?Sized, [src]
S: TryStream + ?Sized,
fn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>, [src]
Self::Error: Into<E>,
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnMut(Self::Ok) -> T, [src]
F: FnMut(Self::Ok) -> T,
fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnMut(Self::Error) -> E, [src]
F: FnMut(Self::Error) -> E,
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>, [src]
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>, [src]
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnMut(&Self::Ok), [src]
F: FnMut(&Self::Ok),
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnMut(&Self::Error), [src]
F: FnMut(&Self::Error),
fn into_stream(self) -> IntoStream<Self>[src]
ⓘImportant traits for TryNext<'_, St>fn try_next(&mut self) -> TryNext<Self> where
Self: Unpin, [src]
ⓘImportant traits for TryNext<'_, St>
Self: Unpin,
ⓘImportant traits for TryForEach<St, Fut, F>fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>, [src]
ⓘImportant traits for TryForEach<St, Fut, F>
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>,
fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>, [src]
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
ⓘImportant traits for TryForEachConcurrent<St, Fut, F>fn try_for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>, [src]
ⓘImportant traits for TryForEachConcurrent<St, Fut, F>
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>,
ⓘImportant traits for TryCollect<St, C>fn try_collect<C>(self) -> TryCollect<Self, C> where
C: Default + Extend<Self::Ok>, [src]
ⓘImportant traits for TryCollect<St, C>
C: Default + Extend<Self::Ok>,
fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: Future<Output = bool>, [src]
F: FnMut(&Self::Ok) -> Fut,
Fut: Future<Output = bool>,
fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>, [src]
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
fn try_flatten(self) -> TryFlatten<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>, [src]
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
ⓘImportant traits for TryFold<St, Fut, T, F>fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F> where
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>, [src]
ⓘImportant traits for TryFold<St, Fut, T, F>
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>,
ⓘImportant traits for TryConcat<St>fn try_concat(self) -> TryConcat<Self> where
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default, [src]
ⓘImportant traits for TryConcat<St>
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default,
fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error, [src]
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
fn try_poll_next_unpin(
&mut self,
cx: &mut Context
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin, [src]
&mut self,
cx: &mut Context
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin,
ⓘImportant traits for Compat<R>fn compat(self) -> Compat<Self> where
Self: Unpin, [src]
ⓘImportant traits for Compat<R>
Self: Unpin,
fn into_async_read(self) -> IntoAsyncRead<Self> where
Self: TryStreamExt<Error = Error> + Unpin,
Self::Ok: AsRef<[u8]>, [src]
Self: TryStreamExt<Error = Error> + Unpin,
Self::Ok: AsRef<[u8]>,
impl<T, Item> SinkExt<Item> for T where
T: Sink<Item> + ?Sized, [src]
T: Sink<Item> + ?Sized,
fn with<U, Fut, F, E>(self, f: F) -> With<Self, Item, U, Fut, F> where
E: From<Self::Error>,
F: FnMut(U) -> Fut,
Fut: Future<Output = Result<Item, E>>, [src]
E: From<Self::Error>,
F: FnMut(U) -> Fut,
Fut: Future<Output = Result<Item, E>>,
fn with_flat_map<U, St, F>(self, f: F) -> WithFlatMap<Self, Item, U, St, F> where
F: FnMut(U) -> St,
St: Stream<Item = Result<Item, Self::Error>>, [src]
F: FnMut(U) -> St,
St: Stream<Item = Result<Item, Self::Error>>,
fn sink_map_err<E, F>(self, f: F) -> SinkMapErr<Self, F> where
F: FnOnce(Self::Error) -> E, [src]
F: FnOnce(Self::Error) -> E,
fn sink_err_into<E>(self) -> SinkErrInto<Self, Item, E> where
Self::Error: Into<E>, [src]
Self::Error: Into<E>,
fn buffer(self, capacity: usize) -> Buffer<Self, Item>[src]
ⓘImportant traits for Close<'_, Si, Item>fn close(&mut self) -> Close<Self, Item> where
Self: Unpin, [src]
ⓘImportant traits for Close<'_, Si, Item>
Self: Unpin,
fn fanout<Si>(self, other: Si) -> Fanout<Self, Si> where
Item: Clone,
Si: Sink<Item, Error = Self::Error>, [src]
Item: Clone,
Si: Sink<Item, Error = Self::Error>,
ⓘImportant traits for Flush<'_, Si, Item>fn flush(&mut self) -> Flush<Self, Item> where
Self: Unpin, [src]
ⓘImportant traits for Flush<'_, Si, Item>
Self: Unpin,
ⓘImportant traits for Send<'_, Si, Item>fn send(&mut self, item: Item) -> Send<Self, Item> where
Self: Unpin, [src]
ⓘImportant traits for Send<'_, Si, Item>
Self: Unpin,
ⓘImportant traits for SendAll<'_, Si, St>fn send_all<St>(&'a mut self, stream: &'a mut St) -> SendAll<'a, Self, St> where
Self: Unpin,
St: TryStream<Ok = Item, Error = Self::Error> + Stream + Unpin + ?Sized, [src]
ⓘImportant traits for SendAll<'_, Si, St>
Self: Unpin,
St: TryStream<Ok = Item, Error = Self::Error> + Stream + Unpin + ?Sized,
ⓘImportant traits for Either<A, B>fn left_sink<Si2>(self) -> Either<Self, Si2> where
Si2: Sink<Item, Error = Self::Error>, [src]
ⓘImportant traits for Either<A, B>
Si2: Sink<Item, Error = Self::Error>,
ⓘImportant traits for Either<A, B>fn right_sink<Si1>(self) -> Either<Si1, Self> where
Si1: Sink<Item, Error = Self::Error>, [src]
ⓘImportant traits for Either<A, B>
Si1: Sink<Item, Error = Self::Error>,
fn compat(self) -> CompatSink<Self, Item> where
Self: Unpin, [src]
Self: Unpin,