Enum holochain::prelude::kitsune_p2p::dependencies::kitsune_p2p_types::dependencies::futures::prelude::future::Either
pub enum Either<A, B> {
Left(A),
Right(B),
}
Expand description
Combines two different futures, streams, or sinks having the same associated types into a single type.
This is useful when conditionally choosing between two distinct future types:
use futures::future::Either;
let cond = true;
let fut = if cond {
Either::Left(async move { 12 })
} else {
Either::Right(async move { 44 })
};
assert_eq!(fut.await, 12);
Variants§
Implementations§
§impl<A, B> Either<A, B>
impl<A, B> Either<A, B>
§impl<A, B, T> Either<(T, A), (T, B)>
impl<A, B, T> Either<(T, A), (T, B)>
pub fn factor_first(self) -> (T, Either<A, B>)
pub fn factor_first(self) -> (T, Either<A, B>)
Factor out a homogeneous type from an either of pairs.
Here, the homogeneous type is the first element of the pairs.
§impl<A, B, T> Either<(A, T), (B, T)>
impl<A, B, T> Either<(A, T), (B, T)>
pub fn factor_second(self) -> (Either<A, B>, T)
pub fn factor_second(self) -> (Either<A, B>, T)
Factor out a homogeneous type from an either of pairs.
Here, the homogeneous type is the second element of the pairs.
§impl<T> Either<T, T>
impl<T> Either<T, T>
pub fn into_inner(self) -> T
pub fn into_inner(self) -> T
Extract the value of an either over two equivalent types.
Trait Implementations§
§impl<A, B> AsyncBufRead for Either<A, B>where
A: AsyncBufRead,
B: AsyncBufRead,
impl<A, B> AsyncBufRead for Either<A, B>where A: AsyncBufRead, B: AsyncBufRead,
§impl<A, B> AsyncRead for Either<A, B>where
A: AsyncRead,
B: AsyncRead,
impl<A, B> AsyncRead for Either<A, B>where A: AsyncRead, B: AsyncRead,
§impl<A, B> AsyncWrite for Either<A, B>where
A: AsyncWrite,
B: AsyncWrite,
impl<A, B> AsyncWrite for Either<A, B>where A: AsyncWrite, B: AsyncWrite,
§fn poll_write(
self: Pin<&mut Either<A, B>>,
cx: &mut Context<'_>,
buf: &[u8]
) -> Poll<Result<usize, Error>>
fn poll_write( self: Pin<&mut Either<A, B>>, cx: &mut Context<'_>, buf: &[u8] ) -> Poll<Result<usize, Error>>
Attempt to write bytes from
buf
into the object. Read more§fn poll_write_vectored(
self: Pin<&mut Either<A, B>>,
cx: &mut Context<'_>,
bufs: &[IoSlice<'_>]
) -> Poll<Result<usize, Error>>
fn poll_write_vectored( self: Pin<&mut Either<A, B>>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>] ) -> Poll<Result<usize, Error>>
Attempt to write bytes from
bufs
into the object using vectored
IO operations. Read more§impl<A, B> FusedFuture for Either<A, B>where
A: FusedFuture,
B: FusedFuture<Output = <A as Future>::Output>,
impl<A, B> FusedFuture for Either<A, B>where A: FusedFuture, B: FusedFuture<Output = <A as Future>::Output>,
§fn is_terminated(&self) -> bool
fn is_terminated(&self) -> bool
Returns
true
if the underlying future should no longer be polled.§impl<A, B> FusedStream for Either<A, B>where
A: FusedStream,
B: FusedStream<Item = <A as Stream>::Item>,
impl<A, B> FusedStream for Either<A, B>where A: FusedStream, B: FusedStream<Item = <A as Stream>::Item>,
§fn is_terminated(&self) -> bool
fn is_terminated(&self) -> bool
Returns
true
if the stream should no longer be polled.§impl<A, B, Item> Sink<Item> for Either<A, B>where
A: Sink<Item>,
B: Sink<Item, Error = <A as Sink<Item>>::Error>,
impl<A, B, Item> Sink<Item> for Either<A, B>where A: Sink<Item>, B: Sink<Item, Error = <A as Sink<Item>>::Error>,
§fn poll_ready(
self: Pin<&mut Either<A, B>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Either<A, B> as Sink<Item>>::Error>>
fn poll_ready( self: Pin<&mut Either<A, B>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Either<A, B> as Sink<Item>>::Error>>
Attempts to prepare the
Sink
to receive a value. Read more§fn start_send(
self: Pin<&mut Either<A, B>>,
item: Item
) -> Result<(), <Either<A, B> as Sink<Item>>::Error>
fn start_send( self: Pin<&mut Either<A, B>>, item: Item ) -> Result<(), <Either<A, B> as Sink<Item>>::Error>
Begin the process of sending a value to the sink.
Each call to this function must be preceded by a successful call to
poll_ready
which returned Poll::Ready(Ok(()))
. Read more§impl<A, B> Stream for Either<A, B>where
A: Stream,
B: Stream<Item = <A as Stream>::Item>,
impl<A, B> Stream for Either<A, B>where A: Stream, B: Stream<Item = <A as Stream>::Item>,
Auto Trait Implementations§
impl<A, B> RefUnwindSafe for Either<A, B>where A: RefUnwindSafe, B: RefUnwindSafe,
impl<A, B> Send for Either<A, B>where A: Send, B: Send,
impl<A, B> Sync for Either<A, B>where A: Sync, B: Sync,
impl<A, B> Unpin for Either<A, B>where A: Unpin, B: Unpin,
impl<A, B> UnwindSafe for Either<A, B>where A: UnwindSafe, B: UnwindSafe,
Blanket Implementations§
§impl<T> ArchivePointee for T
impl<T> ArchivePointee for T
§type ArchivedMetadata = ()
type ArchivedMetadata = ()
The archived version of the pointer metadata for this type.
§fn pointer_metadata(
_: &<T as ArchivePointee>::ArchivedMetadata
) -> <T as Pointee>::Metadata
fn pointer_metadata( _: &<T as ArchivePointee>::ArchivedMetadata ) -> <T as Pointee>::Metadata
Converts some archived metadata to the pointer metadata for itself.
§impl<R> AsyncBufReadExt for Rwhere
R: AsyncBufRead + ?Sized,
impl<R> AsyncBufReadExt for Rwhere R: AsyncBufRead + ?Sized,
§fn fill_buf(&mut self) -> FillBuf<'_, Self> ⓘwhere
Self: Unpin,
fn fill_buf(&mut self) -> FillBuf<'_, Self> ⓘwhere Self: Unpin,
Creates a future which will wait for a non-empty buffer to be available from this I/O
object or EOF to be reached. Read more
§fn consume_unpin(&mut self, amt: usize)where
Self: Unpin,
fn consume_unpin(&mut self, amt: usize)where Self: Unpin,
§fn read_until<'a>(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8, Global>
) -> ReadUntil<'a, Self> ⓘwhere
Self: Unpin,
fn read_until<'a>( &'a mut self, byte: u8, buf: &'a mut Vec<u8, Global> ) -> ReadUntil<'a, Self> ⓘwhere Self: Unpin,
Creates a future which will read all the bytes associated with this I/O
object into
buf
until the delimiter byte
or EOF is reached.
This method is the async equivalent to BufRead::read_until
. Read more§fn read_line<'a>(&'a mut self, buf: &'a mut String) -> ReadLine<'a, Self> ⓘwhere
Self: Unpin,
fn read_line<'a>(&'a mut self, buf: &'a mut String) -> ReadLine<'a, Self> ⓘwhere Self: Unpin,
Creates a future which will read all the bytes associated with this I/O
object into
buf
until a newline (the 0xA byte) or EOF is reached,
This method is the async equivalent to BufRead::read_line
. Read more§impl<R> AsyncBufReadExt for Rwhere
R: AsyncBufRead + ?Sized,
impl<R> AsyncBufReadExt for Rwhere R: AsyncBufRead + ?Sized,
§fn fill_buf(&mut self) -> FillBuf<'_, Self> ⓘwhere
Self: Unpin,
fn fill_buf(&mut self) -> FillBuf<'_, Self> ⓘwhere Self: Unpin,
Returns the contents of the internal buffer, filling it with more data if empty. Read more
§fn read_until<'a>(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8, Global>
) -> ReadUntilFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_until<'a>( &'a mut self, byte: u8, buf: &'a mut Vec<u8, Global> ) -> ReadUntilFuture<'a, Self> ⓘwhere Self: Unpin,
§fn read_line<'a>(&'a mut self, buf: &'a mut String) -> ReadLineFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_line<'a>(&'a mut self, buf: &'a mut String) -> ReadLineFuture<'a, Self> ⓘwhere Self: Unpin,
Reads all bytes and appends them into
buf
until a newline (the 0xA byte) or EOF is found. Read more§impl<R> AsyncReadExt for Rwhere
R: AsyncRead + ?Sized,
impl<R> AsyncReadExt for Rwhere R: AsyncRead + ?Sized,
§fn chain<R>(self, next: R) -> Chain<Self, R>where
Self: Sized,
R: AsyncRead,
fn chain<R>(self, next: R) -> Chain<Self, R>where Self: Sized, R: AsyncRead,
Creates an adaptor which will chain this stream with another. Read more
§fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self> ⓘwhere
Self: Unpin,
fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self> ⓘwhere Self: Unpin,
Tries to read some bytes directly into the given
buf
in asynchronous
manner, returning a future type. Read more§fn read_vectored<'a>(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectored<'a, Self> ⓘwhere
Self: Unpin,
fn read_vectored<'a>( &'a mut self, bufs: &'a mut [IoSliceMut<'a>] ) -> ReadVectored<'a, Self> ⓘwhere Self: Unpin,
Creates a future which will read from the
AsyncRead
into bufs
using vectored
IO operations. Read more§fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self> ⓘwhere
Self: Unpin,
fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self> ⓘwhere Self: Unpin,
Creates a future which will read exactly enough bytes to fill
buf
,
returning an error if end of file (EOF) is hit sooner. Read more§fn read_to_end<'a>(
&'a mut self,
buf: &'a mut Vec<u8, Global>
) -> ReadToEnd<'a, Self> ⓘwhere
Self: Unpin,
fn read_to_end<'a>( &'a mut self, buf: &'a mut Vec<u8, Global> ) -> ReadToEnd<'a, Self> ⓘwhere Self: Unpin,
Creates a future which will read all the bytes from this
AsyncRead
. Read more§fn read_to_string<'a>(
&'a mut self,
buf: &'a mut String
) -> ReadToString<'a, Self> ⓘwhere
Self: Unpin,
fn read_to_string<'a>( &'a mut self, buf: &'a mut String ) -> ReadToString<'a, Self> ⓘwhere Self: Unpin,
Creates a future which will read all the bytes from this
AsyncRead
. Read more§impl<R> AsyncReadExt for Rwhere
R: AsyncRead + ?Sized,
impl<R> AsyncReadExt for Rwhere R: AsyncRead + ?Sized,
§fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadFuture<'a, Self> ⓘwhere Self: Unpin,
Reads some bytes from the byte stream. Read more
§fn read_vectored<'a>(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectoredFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_vectored<'a>( &'a mut self, bufs: &'a mut [IoSliceMut<'a>] ) -> ReadVectoredFuture<'a, Self> ⓘwhere Self: Unpin,
§fn read_to_end<'a>(
&'a mut self,
buf: &'a mut Vec<u8, Global>
) -> ReadToEndFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_to_end<'a>( &'a mut self, buf: &'a mut Vec<u8, Global> ) -> ReadToEndFuture<'a, Self> ⓘwhere Self: Unpin,
§fn read_to_string<'a>(
&'a mut self,
buf: &'a mut String
) -> ReadToStringFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_to_string<'a>( &'a mut self, buf: &'a mut String ) -> ReadToStringFuture<'a, Self> ⓘwhere Self: Unpin,
§fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExactFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExactFuture<'a, Self> ⓘwhere Self: Unpin,
Reads the exact number of bytes required to fill
buf
. Read more§fn take(self, limit: u64) -> Take<Self>where
Self: Sized,
fn take(self, limit: u64) -> Take<Self>where Self: Sized,
Creates an adapter which will read at most
limit
bytes from it. Read more§impl<S> AsyncSeekExt for Swhere
S: AsyncSeek + ?Sized,
impl<S> AsyncSeekExt for Swhere S: AsyncSeek + ?Sized,
§impl<W> AsyncWriteExt for Wwhere
W: AsyncWrite + ?Sized,
impl<W> AsyncWriteExt for Wwhere W: AsyncWrite + ?Sized,
§fn flush(&mut self) -> Flush<'_, Self> ⓘwhere
Self: Unpin,
fn flush(&mut self) -> Flush<'_, Self> ⓘwhere Self: Unpin,
Creates a future which will entirely flush this
AsyncWrite
. Read more§fn close(&mut self) -> Close<'_, Self> ⓘwhere
Self: Unpin,
fn close(&mut self) -> Close<'_, Self> ⓘwhere Self: Unpin,
Creates a future which will entirely close this
AsyncWrite
.§fn write<'a>(&'a mut self, buf: &'a [u8]) -> Write<'a, Self> ⓘwhere
Self: Unpin,
fn write<'a>(&'a mut self, buf: &'a [u8]) -> Write<'a, Self> ⓘwhere Self: Unpin,
Creates a future which will write bytes from
buf
into the object. Read more§fn write_vectored<'a>(
&'a mut self,
bufs: &'a [IoSlice<'a>]
) -> WriteVectored<'a, Self> ⓘwhere
Self: Unpin,
fn write_vectored<'a>( &'a mut self, bufs: &'a [IoSlice<'a>] ) -> WriteVectored<'a, Self> ⓘwhere Self: Unpin,
Creates a future which will write bytes from
bufs
into the object using vectored
IO operations. Read more§impl<W> AsyncWriteExt for Wwhere
W: AsyncWrite + ?Sized,
impl<W> AsyncWriteExt for Wwhere W: AsyncWrite + ?Sized,
§fn write<'a>(&'a mut self, buf: &'a [u8]) -> WriteFuture<'a, Self> ⓘwhere
Self: Unpin,
fn write<'a>(&'a mut self, buf: &'a [u8]) -> WriteFuture<'a, Self> ⓘwhere Self: Unpin,
Writes some bytes into the byte stream. Read more
§fn write_vectored<'a>(
&'a mut self,
bufs: &'a [IoSlice<'a>]
) -> WriteVectoredFuture<'a, Self> ⓘwhere
Self: Unpin,
fn write_vectored<'a>( &'a mut self, bufs: &'a [IoSlice<'a>] ) -> WriteVectoredFuture<'a, Self> ⓘwhere Self: Unpin,
§fn write_all<'a>(&'a mut self, buf: &'a [u8]) -> WriteAllFuture<'a, Self> ⓘwhere
Self: Unpin,
fn write_all<'a>(&'a mut self, buf: &'a [u8]) -> WriteAllFuture<'a, Self> ⓘwhere Self: Unpin,
Writes an entire buffer into the byte stream. Read more
§fn flush(&mut self) -> FlushFuture<'_, Self> ⓘwhere
Self: Unpin,
fn flush(&mut self) -> FlushFuture<'_, Self> ⓘwhere Self: Unpin,
Flushes the stream to ensure that all buffered contents reach their destination. Read more
§fn boxed_writer<'a>(self) -> Pin<Box<dyn AsyncWrite + Send + 'a, Global>>where
Self: Sized + Send + 'a,
fn boxed_writer<'a>(self) -> Pin<Box<dyn AsyncWrite + Send + 'a, Global>>where Self: Sized + Send + 'a,
Boxes the writer and changes its type to
dyn AsyncWrite + Send + 'a
. Read moresource§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> BufReadExt for Twhere
T: AsyncBufRead + ?Sized,
impl<T> BufReadExt for Twhere T: AsyncBufRead + ?Sized,
§fn read_until<'a>(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8, Global>
) -> ReadUntilFuture<'a, Self>where
Self: Unpin,
fn read_until<'a>( &'a mut self, byte: u8, buf: &'a mut Vec<u8, Global> ) -> ReadUntilFuture<'a, Self>where Self: Unpin,
§fn read_line<'a>(&'a mut self, buf: &'a mut String) -> ReadLineFuture<'a, Self>where
Self: Unpin,
fn read_line<'a>(&'a mut self, buf: &'a mut String) -> ReadLineFuture<'a, Self>where Self: Unpin,
Reads all bytes and appends them into
buf
until a newline (the 0xA byte) is
reached. Read more§impl<F, W, T, D> Deserialize<With<T, W>, D> for Fwhere
W: DeserializeWith<F, T, D>,
D: Fallible + ?Sized,
F: ?Sized,
impl<F, W, T, D> Deserialize<With<T, W>, D> for Fwhere W: DeserializeWith<F, T, D>, D: Fallible + ?Sized, F: ?Sized,
§fn deserialize(
&self,
deserializer: &mut D
) -> Result<With<T, W>, <D as Fallible>::Error>
fn deserialize( &self, deserializer: &mut D ) -> Result<With<T, W>, <D as Fallible>::Error>
Deserializes using the given deserializer
§impl<T> FutureExt for Twhere
T: Future + ?Sized,
impl<T> FutureExt for Twhere T: Future + ?Sized,
§fn map<U, F>(self, f: F) -> Map<Self, F> ⓘwhere
F: FnOnce(Self::Output) -> U,
Self: Sized,
fn map<U, F>(self, f: F) -> Map<Self, F> ⓘwhere F: FnOnce(Self::Output) -> U, Self: Sized,
Map this future’s output to a different type, returning a new future of
the resulting type. Read more
§fn map_into<U>(self) -> MapInto<Self, U> ⓘwhere
Self::Output: Into<U>,
Self: Sized,
fn map_into<U>(self) -> MapInto<Self, U> ⓘwhere Self::Output: Into<U>, Self: Sized,
Map this future’s output to a different type, returning a new future of
the resulting type. Read more
§fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> ⓘwhere
F: FnOnce(Self::Output) -> Fut,
Fut: Future,
Self: Sized,
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> ⓘwhere F: FnOnce(Self::Output) -> Fut, Fut: Future, Self: Sized,
Chain on a computation for when a future finished, passing the result of
the future to the provided closure
f
. Read more§fn into_stream(self) -> IntoStream<Self>where
Self: Sized,
fn into_stream(self) -> IntoStream<Self>where Self: Sized,
Convert this future into a single element stream. Read more
§fn flatten(self) -> Flatten<Self> ⓘwhere
Self::Output: Future,
Self: Sized,
fn flatten(self) -> Flatten<Self> ⓘwhere Self::Output: Future, Self: Sized,
Flatten the execution of this future when the output of this
future is itself another future. Read more
§fn flatten_stream(self) -> FlattenStream<Self>where
Self::Output: Stream,
Self: Sized,
fn flatten_stream(self) -> FlattenStream<Self>where Self::Output: Stream, Self: Sized,
Flatten the execution of this future when the successful result of this
future is a stream. Read more
§fn fuse(self) -> Fuse<Self> ⓘwhere
Self: Sized,
fn fuse(self) -> Fuse<Self> ⓘwhere Self: Sized,
Fuse a future such that
poll
will never again be called once it has
completed. This method can be used to turn any Future
into a
FusedFuture
. Read more§fn inspect<F>(self, f: F) -> Inspect<Self, F> ⓘwhere
F: FnOnce(&Self::Output),
Self: Sized,
fn inspect<F>(self, f: F) -> Inspect<Self, F> ⓘwhere F: FnOnce(&Self::Output), Self: Sized,
Do something with the output of a future before passing it on. Read more
§fn catch_unwind(self) -> CatchUnwind<Self> ⓘwhere
Self: Sized + UnwindSafe,
fn catch_unwind(self) -> CatchUnwind<Self> ⓘwhere Self: Sized + UnwindSafe,
Catches unwinding panics while polling the future. Read more
Create a cloneable handle to this future where all handles will resolve
to the same result. Read more
§fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)where
Self: Sized,
fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)where Self: Sized,
Turn this future into a future that yields
()
on completion and sends
its output to another future on a separate task. Read more§fn boxed<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + Send + 'a, Global>>where
Self: Sized + Send + 'a,
fn boxed<'a>( self ) -> Pin<Box<dyn Future<Output = Self::Output> + Send + 'a, Global>>where Self: Sized + Send + 'a,
Wrap the future in a Box, pinning it. Read more
§fn boxed_local<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>>where
Self: Sized + 'a,
fn boxed_local<'a>( self ) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>>where Self: Sized + 'a,
Wrap the future in a Box, pinning it. Read more
§fn unit_error(self) -> UnitError<Self> ⓘwhere
Self: Sized,
fn unit_error(self) -> UnitError<Self> ⓘwhere Self: Sized,
Turns a
Future<Output = T>
into a
TryFuture<Ok = T, Error = ()
>.§fn never_error(self) -> NeverError<Self> ⓘwhere
Self: Sized,
fn never_error(self) -> NeverError<Self> ⓘwhere Self: Sized,
Turns a
Future<Output = T>
into a
TryFuture<Ok = T, Error = Never
>.§impl<T> FutureExt for T
impl<T> FutureExt for T
§fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
§fn with_current_context(self) -> WithContext<Self> ⓘ
fn with_current_context(self) -> WithContext<Self> ⓘ
§impl<T> FutureExt for Twhere
T: Future + ?Sized,
impl<T> FutureExt for Twhere T: Future + ?Sized,
§fn delay(self, dur: Duration) -> DelayFuture<Self>where
Self: Sized,
fn delay(self, dur: Duration) -> DelayFuture<Self>where Self: Sized,
Returns a Future that delays execution for a specified time. Read more
§fn flatten(self) -> FlattenFuture<Self, <Self::Output as IntoFuture>::Future>where
Self: Sized,
Self::Output: IntoFuture,
fn flatten(self) -> FlattenFuture<Self, <Self::Output as IntoFuture>::Future>where Self: Sized, Self::Output: IntoFuture,
Flatten out the execution of this future when the result itself
can be converted into another future. Read more
§fn race<F>(self, other: F) -> Race<Self, F>where
Self: Future + Sized,
F: Future<Output = Self::Output>,
fn race<F>(self, other: F) -> Race<Self, F>where Self: Future + Sized, F: Future<Output = Self::Output>,
Waits for one of two similarly-typed futures to complete. Read more
§fn try_race<F, T, E>(self, other: F) -> TryRace<Self, F>where
Self: Future<Output = Result<T, E>> + Sized,
F: Future<Output = Self::Output>,
fn try_race<F, T, E>(self, other: F) -> TryRace<Self, F>where Self: Future<Output = Result<T, E>> + Sized, F: Future<Output = Self::Output>,
Waits for one of two similarly-typed fallible futures to complete. Read more
§fn join<F>(self, other: F) -> Join<Self, F>where
Self: Future + Sized,
F: Future,
fn join<F>(self, other: F) -> Join<Self, F>where Self: Future + Sized, F: Future,
Waits for two similarly-typed futures to complete. Read more
§impl<F> FutureExt for Fwhere
F: Future + ?Sized,
impl<F> FutureExt for Fwhere F: Future + ?Sized,
§fn catch_unwind(self) -> CatchUnwind<Self> ⓘwhere
Self: Sized + UnwindSafe,
fn catch_unwind(self) -> CatchUnwind<Self> ⓘwhere Self: Sized + UnwindSafe,
Catches panics while polling the future. Read more
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
source§fn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
source§fn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
source§impl<F> IntoFuture for Fwhere
F: Future,
impl<F> IntoFuture for Fwhere F: Future,
§type IntoFuture = F
type IntoFuture = F
Which kind of future are we turning this into?
source§fn into_future(self) -> <F as IntoFuture>::IntoFuture
fn into_future(self) -> <F as IntoFuture>::IntoFuture
Creates a future from a value. Read more
source§impl<T> IntoMustBoxFuture for Twhere
T: Future + ?Sized,
impl<T> IntoMustBoxFuture for Twhere T: Future + ?Sized,
§impl<I> IntoStream for Iwhere
I: Stream,
impl<I> IntoStream for Iwhere I: Stream,
§type IntoStream = I
type IntoStream = I
Which kind of stream are we turning this into?
§fn into_stream(self) -> I
fn into_stream(self) -> I
Creates a stream from a value.
§impl<T> Pointable for T
impl<T> Pointable for T
§impl<T> ReadExt for Twhere
T: AsyncRead + ?Sized,
impl<T> ReadExt for Twhere T: AsyncRead + ?Sized,
§fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadFuture<'a, Self>where
Self: Unpin,
fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadFuture<'a, Self>where Self: Unpin,
Reads some bytes from the byte stream. Read more
§fn read_vectored<'a>(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectoredFuture<'a, Self>where
Self: Unpin,
fn read_vectored<'a>( &'a mut self, bufs: &'a mut [IoSliceMut<'a>] ) -> ReadVectoredFuture<'a, Self>where Self: Unpin,
§fn read_to_end<'a>(
&'a mut self,
buf: &'a mut Vec<u8, Global>
) -> ReadToEndFuture<'a, Self>where
Self: Unpin,
fn read_to_end<'a>( &'a mut self, buf: &'a mut Vec<u8, Global> ) -> ReadToEndFuture<'a, Self>where Self: Unpin,
Reads all bytes from the byte stream. Read more
§fn read_to_string<'a>(
&'a mut self,
buf: &'a mut String
) -> ReadToStringFuture<'a, Self>where
Self: Unpin,
fn read_to_string<'a>( &'a mut self, buf: &'a mut String ) -> ReadToStringFuture<'a, Self>where Self: Unpin,
Reads all bytes from the byte stream and appends them into a string. Read more
§fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExactFuture<'a, Self>where
Self: Unpin,
fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExactFuture<'a, Self>where Self: Unpin,
Reads the exact number of bytes required to fill
buf
. Read more§fn take(self, limit: u64) -> Take<Self>where
Self: Sized,
fn take(self, limit: u64) -> Take<Self>where Self: Sized,
Creates an adaptor which will read at most
limit
bytes from it. Read more§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,
Creates a “by reference” adaptor for this instance of
Read
. Read more§impl<T, Item> SinkExt<Item> for Twhere
T: Sink<Item> + ?Sized,
impl<T, Item> SinkExt<Item> for Twhere T: Sink<Item> + ?Sized,
§fn with<U, Fut, F, E>(self, f: F) -> With<Self, Item, U, Fut, F>where
F: FnMut(U) -> Fut,
Fut: Future<Output = Result<Item, E>>,
E: From<Self::Error>,
Self: Sized,
fn with<U, Fut, F, E>(self, f: F) -> With<Self, Item, U, Fut, F>where F: FnMut(U) -> Fut, Fut: Future<Output = Result<Item, E>>, E: From<Self::Error>, Self: Sized,
Composes a function in front of the sink. Read more
§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>>,
Self: Sized,
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>>, Self: Sized,
Composes a function in front of the sink. Read more
§fn sink_map_err<E, F>(self, f: F) -> SinkMapErr<Self, F>where
F: FnOnce(Self::Error) -> E,
Self: Sized,
fn sink_map_err<E, F>(self, f: F) -> SinkMapErr<Self, F>where F: FnOnce(Self::Error) -> E, Self: Sized,
Transforms the error returned by the sink.
§fn sink_err_into<E>(self) -> SinkErrInto<Self, Item, E>where
Self: Sized,
Self::Error: Into<E>,
fn sink_err_into<E>(self) -> SinkErrInto<Self, Item, E>where Self: Sized, Self::Error: Into<E>,
Map this sink’s error to a different error type using the
Into
trait. Read more§fn buffer(self, capacity: usize) -> Buffer<Self, Item>where
Self: Sized,
fn buffer(self, capacity: usize) -> Buffer<Self, Item>where Self: Sized,
Adds a fixed-size buffer to the current sink. Read more
§fn fanout<Si>(self, other: Si) -> Fanout<Self, Si>where
Self: Sized,
Item: Clone,
Si: Sink<Item, Error = Self::Error>,
fn fanout<Si>(self, other: Si) -> Fanout<Self, Si>where Self: Sized, Item: Clone, Si: Sink<Item, Error = Self::Error>,
Fanout items to multiple sinks. Read more
§fn flush(&mut self) -> Flush<'_, Self, Item> ⓘwhere
Self: Unpin,
fn flush(&mut self) -> Flush<'_, Self, Item> ⓘwhere Self: Unpin,
Flush the sink, processing all pending items. Read more
§fn send(&mut self, item: Item) -> Send<'_, Self, Item> ⓘwhere
Self: Unpin,
fn send(&mut self, item: Item) -> Send<'_, Self, Item> ⓘwhere Self: Unpin,
A future that completes after the given item has been fully processed
into the sink, including flushing. Read more
§fn feed(&mut self, item: Item) -> Feed<'_, Self, Item> ⓘwhere
Self: Unpin,
fn feed(&mut self, item: Item) -> Feed<'_, Self, Item> ⓘwhere Self: Unpin,
A future that completes after the given item has been received
by the sink. Read more
§fn send_all<St, 'a>(&'a mut self, stream: &'a mut St) -> SendAll<'a, Self, St> ⓘwhere
St: TryStream<Ok = Item, Error = Self::Error> + Stream + Unpin + ?Sized,
Self: Unpin,
fn send_all<St, 'a>(&'a mut self, stream: &'a mut St) -> SendAll<'a, Self, St> ⓘwhere St: TryStream<Ok = Item, Error = Self::Error> + Stream + Unpin + ?Sized, Self: Unpin,
A future that completes after the given stream has been fully processed
into the sink, including flushing. Read more
§fn left_sink<Si2>(self) -> Either<Self, Si2> ⓘwhere
Si2: Sink<Item, Error = Self::Error>,
Self: Sized,
fn left_sink<Si2>(self) -> Either<Self, Si2> ⓘwhere Si2: Sink<Item, Error = Self::Error>, Self: Sized,
§fn right_sink<Si1>(self) -> Either<Si1, Self> ⓘwhere
Si1: Sink<Item, Error = Self::Error>,
Self: Sized,
fn right_sink<Si1>(self) -> Either<Si1, Self> ⓘwhere Si1: Sink<Item, Error = Self::Error>, Self: Sized,
§fn poll_ready_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>where
Self: Unpin,
fn poll_ready_unpin( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), Self::Error>>where Self: Unpin,
A convenience method for calling
Sink::poll_ready
on Unpin
sink types.§fn start_send_unpin(&mut self, item: Item) -> Result<(), Self::Error>where
Self: Unpin,
fn start_send_unpin(&mut self, item: Item) -> Result<(), Self::Error>where Self: Unpin,
A convenience method for calling
Sink::start_send
on Unpin
sink types.§fn poll_flush_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>where
Self: Unpin,
fn poll_flush_unpin( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), Self::Error>>where Self: Unpin,
A convenience method for calling
Sink::poll_flush
on Unpin
sink types.§fn poll_close_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>where
Self: Unpin,
fn poll_close_unpin( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), Self::Error>>where Self: Unpin,
A convenience method for calling
Sink::poll_close
on Unpin
sink types.§impl<Item, S> SinkRateLimitExt<Item, S> for Swhere
S: Sink<Item>,
impl<Item, S> SinkRateLimitExt<Item, S> for Swhere S: Sink<Item>,
§fn ratelimit_sink<D, C>(
self,
limiter: &RateLimiter<NotKeyed, D, C>
) -> RatelimitedSink<'_, Item, S, D, C>where
D: DirectStateStore,
C: ReasonablyRealtime,
fn ratelimit_sink<D, C>( self, limiter: &RateLimiter<NotKeyed, D, C> ) -> RatelimitedSink<'_, Item, S, D, C>where D: DirectStateStore, C: ReasonablyRealtime,
Limits the rate at which items can be put into the current sink.
§fn ratelimit_sink_with_jitter<D, C>(
self,
limiter: &RateLimiter<NotKeyed, D, C>,
jitter: Jitter
) -> RatelimitedSink<'_, Item, S, D, C>where
D: DirectStateStore,
C: ReasonablyRealtime,
fn ratelimit_sink_with_jitter<D, C>( self, limiter: &RateLimiter<NotKeyed, D, C>, jitter: Jitter ) -> RatelimitedSink<'_, Item, S, D, C>where D: DirectStateStore, C: ReasonablyRealtime,
Limits the rate at which items can be put into the current sink, with a randomized wait
period.
§impl<T> StreamExt for Twhere
T: Stream + ?Sized,
impl<T> StreamExt for Twhere T: Stream + ?Sized,
§fn next(&mut self) -> Next<'_, Self> ⓘwhere
Self: Unpin,
fn next(&mut self) -> Next<'_, Self> ⓘwhere Self: Unpin,
Creates a future that resolves to the next item in the stream. Read more
§fn into_future(self) -> StreamFuture<Self> ⓘwhere
Self: Sized + Unpin,
fn into_future(self) -> StreamFuture<Self> ⓘwhere Self: Sized + Unpin,
§fn map<T, F>(self, f: F) -> Map<Self, F>where
F: FnMut(Self::Item) -> T,
Self: Sized,
fn map<T, F>(self, f: F) -> Map<Self, F>where F: FnMut(Self::Item) -> T, Self: Sized,
Maps this stream’s items to a different type, returning a new stream of
the resulting type. Read more
§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where Self: Sized,
Creates a stream which gives the current iteration count as well as
the next value. Read more
§fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F>where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
Self: Sized,
fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F>where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
Filters the values produced by this stream according to the provided
asynchronous predicate. Read more
§fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F>where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>,
Self: Sized,
fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F>where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = Option<T>>, Self: Sized,
Filters the values produced by this stream while simultaneously mapping
them to a different type according to the provided asynchronous closure. Read more
§fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>where
F: FnMut(Self::Item) -> Fut,
Fut: Future,
Self: Sized,
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>where F: FnMut(Self::Item) -> Fut, Fut: Future, Self: Sized,
Computes from this stream’s items new items of a different type using
an asynchronous closure. Read more
§fn collect<C>(self) -> Collect<Self, C> ⓘwhere
C: Default + Extend<Self::Item>,
Self: Sized,
fn collect<C>(self) -> Collect<Self, C> ⓘwhere C: Default + Extend<Self::Item>, Self: Sized,
Transforms a stream into a collection, returning a
future representing the result of that computation. Read more
§fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB> ⓘwhere
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Stream<Item = (A, B)>,
fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB> ⓘwhere FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Stream<Item = (A, B)>,
Converts a stream of pairs into a future, which
resolves to pair of containers. Read more
§fn concat(self) -> Concat<Self> ⓘwhere
Self: Sized,
Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
fn concat(self) -> Concat<Self> ⓘwhere Self: Sized, Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
Concatenate all items of a stream into a single extendable
destination, returning a future representing the end result. Read more
§fn count(self) -> Count<Self> ⓘwhere
Self: Sized,
fn count(self) -> Count<Self> ⓘwhere Self: Sized,
Drives the stream to completion, counting the number of items. Read more
§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>,
Self: Sized,
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>, Self: Sized,
Execute an accumulating asynchronous computation over a stream,
collecting all the values into one final result. Read more
§fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F> ⓘwhere
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,
Self: Sized,
fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F> ⓘwhere F: FnMut(Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
Execute predicate over asynchronous stream, and return
true
if any element in stream satisfied a predicate. Read more§fn all<Fut, F>(self, f: F) -> All<Self, Fut, F> ⓘwhere
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,
Self: Sized,
fn all<Fut, F>(self, f: F) -> All<Self, Fut, F> ⓘwhere F: FnMut(Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
Execute predicate over asynchronous stream, and return
true
if all element in stream satisfied a predicate. Read more§fn flatten(self) -> Flatten<Self>where
Self::Item: Stream,
Self: Sized,
fn flatten(self) -> Flatten<Self>where Self::Item: Stream, Self: Sized,
Flattens a stream of streams into just one continuous stream. Read more
§fn flatten_unordered(
self,
limit: impl Into<Option<usize>>
) -> FlattenUnorderedWithFlowController<Self, ()>where
Self::Item: Stream + Unpin,
Self: Sized,
fn flatten_unordered( self, limit: impl Into<Option<usize>> ) -> FlattenUnorderedWithFlowController<Self, ()>where Self::Item: Stream + Unpin, Self: Sized,
Flattens a stream of streams into just one continuous stream. Polls
inner streams produced by the base stream concurrently. Read more
§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
F: FnMut(Self::Item) -> U,
U: Stream,
Self: Sized,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where F: FnMut(Self::Item) -> U, U: Stream, Self: Sized,
§fn flat_map_unordered<U, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> FlatMapUnordered<Self, U, F>where
U: Stream + Unpin,
F: FnMut(Self::Item) -> U,
Self: Sized,
fn flat_map_unordered<U, F>( self, limit: impl Into<Option<usize>>, f: F ) -> FlatMapUnordered<Self, U, F>where U: Stream + Unpin, F: FnMut(Self::Item) -> U, Self: Sized,
Maps a stream like
StreamExt::map
but flattens nested Stream
s
and polls them concurrently, yielding items in any order, as they made
available. Read more§fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F>where
F: FnMut(&mut S, Self::Item) -> Fut,
Fut: Future<Output = Option<B>>,
Self: Sized,
fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F>where F: FnMut(&mut S, Self::Item) -> Fut, Fut: Future<Output = Option<B>>, Self: Sized,
Combinator similar to
StreamExt::fold
that holds internal state
and produces a new stream. Read more§fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F>where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
Self: Sized,
fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F>where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
Skip elements on this stream while the provided asynchronous predicate
resolves to
true
. Read more§fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F>where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
Self: Sized,
fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F>where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
Take elements from this stream while the provided asynchronous predicate
resolves to
true
. Read more§fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut>where
Fut: Future,
Self: Sized,
fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut>where Fut: Future, Self: Sized,
Take elements from this stream until the provided future resolves. Read more
§fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> ⓘwhere
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
Self: Sized,
fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> ⓘwhere F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>, Self: Sized,
Runs this stream to completion, executing the provided asynchronous
closure for each element on the stream. Read more
§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 = ()>,
Self: Sized,
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 = ()>, Self: Sized,
Runs this stream to completion, executing the provided asynchronous
closure for each element on the stream concurrently as elements become
available. Read more
§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where Self: Sized,
Creates a new stream of at most
n
items of the underlying stream. Read more§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where Self: Sized,
Creates a new stream which skips
n
items of the underlying stream. Read more§fn catch_unwind(self) -> CatchUnwind<Self>where
Self: Sized + UnwindSafe,
fn catch_unwind(self) -> CatchUnwind<Self>where Self: Sized + UnwindSafe,
Catches unwinding panics while polling the stream. Read more
§fn boxed<'a>(
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a, Global>>where
Self: Sized + Send + 'a,
fn boxed<'a>( self ) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a, Global>>where Self: Sized + Send + 'a,
Wrap the stream in a Box, pinning it. Read more
§fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>>where
Self: Sized + 'a,
fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>>where Self: Sized + 'a,
Wrap the stream in a Box, pinning it. Read more
§fn buffered(self, n: usize) -> Buffered<Self>where
Self::Item: Future,
Self: Sized,
fn buffered(self, n: usize) -> Buffered<Self>where Self::Item: Future, Self: Sized,
An adaptor for creating a buffered list of pending futures. Read more
§fn buffer_unordered(self, n: usize) -> BufferUnordered<Self>where
Self::Item: Future,
Self: Sized,
fn buffer_unordered(self, n: usize) -> BufferUnordered<Self>where Self::Item: Future, Self: Sized,
An adaptor for creating a buffered list of pending futures (unordered). Read more
§fn zip<St>(self, other: St) -> Zip<Self, St>where
St: Stream,
Self: Sized,
fn zip<St>(self, other: St) -> Zip<Self, St>where St: Stream, Self: Sized,
An adapter for zipping two streams together. Read more
§fn chain<St>(self, other: St) -> Chain<Self, St>where
St: Stream<Item = Self::Item>,
Self: Sized,
fn chain<St>(self, other: St) -> Chain<Self, St>where St: Stream<Item = Self::Item>, Self: Sized,
Adapter for chaining two streams. Read more
§fn peekable(self) -> Peekable<Self>where
Self: Sized,
fn peekable(self) -> Peekable<Self>where Self: Sized,
Creates a new stream which exposes a
peek
method. Read more§fn chunks(self, capacity: usize) -> Chunks<Self>where
Self: Sized,
fn chunks(self, capacity: usize) -> Chunks<Self>where Self: Sized,
An adaptor for chunking up items of the stream inside a vector. Read more
§fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>where
Self: Sized,
fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>where Self: Sized,
An adaptor for chunking up ready items of the stream inside a vector. Read more
§fn forward<S>(self, sink: S) -> Forward<Self, S> ⓘwhere
S: Sink<Self::Ok, Error = Self::Error>,
Self: TryStream + Sized,
fn forward<S>(self, sink: S) -> Forward<Self, S> ⓘwhere S: Sink<Self::Ok, Error = Self::Error>, Self: TryStream + Sized,
A future that completes after the given stream has been fully processed
into the sink and the sink has been flushed and closed. Read more
§fn inspect<F>(self, f: F) -> Inspect<Self, F>where
F: FnMut(&Self::Item),
Self: Sized,
fn inspect<F>(self, f: F) -> Inspect<Self, F>where F: FnMut(&Self::Item), Self: Sized,
Do something with each item of this stream, afterwards passing it on. Read more
§fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>where
Self: Unpin,
fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>where Self: Unpin,
A convenience method for calling
Stream::poll_next
on Unpin
stream types.§fn select_next_some(&mut self) -> SelectNextSome<'_, Self> ⓘwhere
Self: Unpin + FusedStream,
fn select_next_some(&mut self) -> SelectNextSome<'_, Self> ⓘwhere Self: Unpin + FusedStream,
§impl<T> StreamExt for Twhere
T: Stream + ?Sized,
impl<T> StreamExt for Twhere T: Stream + ?Sized,
§fn next(&mut self) -> NextFuture<'_, Self>where
Self: Unpin,
fn next(&mut self) -> NextFuture<'_, Self>where Self: Unpin,
Advances the stream and returns the next value. Read more
§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where Self: Sized,
Creates a stream that yields its first
n
elements. Read more§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,
Creates a stream that yields elements based on a predicate. Read more
§fn throttle(self, d: Duration) -> Throttle<Self>where
Self: Sized,
fn throttle(self, d: Duration) -> Throttle<Self>where Self: Sized,
Limit the amount of items yielded per timeslice in a stream. Read more
§fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where Self: Sized,
Creates a stream that yields each
step
th element. Read more§fn chain<U>(self, other: U) -> Chain<Self, U>where
Self: Sized,
U: Stream<Item = Self::Item>,
fn chain<U>(self, other: U) -> Chain<Self, U>where Self: Sized, U: Stream<Item = Self::Item>,
Takes two streams and creates a new stream over both in sequence. Read more
§fn cloned<'a, T>(self) -> Cloned<Self>where
Self: Sized + Stream<Item = &'a T>,
T: Clone + 'a,
fn cloned<'a, T>(self) -> Cloned<Self>where Self: Sized + Stream<Item = &'a T>, T: Clone + 'a,
Creates an stream which copies all of its elements. Read more
§fn copied<'a, T>(self) -> Copied<Self>where
Self: Sized + Stream<Item = &'a T>,
T: Copy + 'a,
fn copied<'a, T>(self) -> Copied<Self>where Self: Sized + Stream<Item = &'a T>, T: Copy + 'a,
Creates an stream which copies all of its elements. Read more
§fn cycle(self) -> Cycle<Self>where
Self: Clone + Sized,
fn cycle(self) -> Cycle<Self>where Self: Clone + Sized,
Creates a stream that yields the provided values infinitely and in order. Read more
§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where Self: Sized,
Creates a stream that gives the current element’s count as well as the next value. Read more
§fn delay(self, dur: Duration) -> Delay<Self>where
Self: Sized,
fn delay(self, dur: Duration) -> Delay<Self>where Self: Sized,
Creates a stream that is delayed before it starts yielding items. Read more
§fn map<B, F>(self, f: F) -> Map<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> B,
fn map<B, F>(self, f: F) -> Map<Self, F>where Self: Sized, F: FnMut(Self::Item) -> B,
Takes a closure and creates a stream that calls that closure on every element of this stream. Read more
§fn inspect<F>(self, f: F) -> Inspect<Self, F>where
Self: Sized,
F: FnMut(&Self::Item),
fn inspect<F>(self, f: F) -> Inspect<Self, F>where Self: Sized, F: FnMut(&Self::Item),
A combinator that does something with each element in the stream, passing the value
on. Read more
§fn last(self) -> LastFuture<Self, Self::Item>where
Self: Sized,
fn last(self) -> LastFuture<Self, Self::Item>where Self: Sized,
Returns the last element of the stream. Read more
§fn fuse(self) -> Fuse<Self>where
Self: Sized,
fn fuse(self) -> Fuse<Self>where Self: Sized,
Creates a stream which ends after the first
None
. Read more§fn filter<P>(self, predicate: P) -> Filter<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn filter<P>(self, predicate: P) -> Filter<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,
Creates a stream that uses a predicate to determine if an element should be yielded. Read more
§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
Self: Sized,
U: IntoStream,
F: FnMut(Self::Item) -> U,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where Self: Sized, U: IntoStream, F: FnMut(Self::Item) -> U,
Creates an stream that works like map, but flattens nested structure. Read more
§fn flatten(self) -> Flatten<Self>where
Self: Sized,
Self::Item: IntoStream,
fn flatten(self) -> Flatten<Self>where Self: Sized, Self::Item: IntoStream,
Creates an stream that flattens nested structure. Read more
§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where Self: Sized, F: FnMut(Self::Item) -> Option<B>,
Both filters and maps a stream. Read more
§fn min_by_key<B, F>(self, key_by: F) -> MinByKeyFuture<Self, Self::Item, F>where
Self: Sized,
B: Ord,
F: FnMut(&Self::Item) -> B,
fn min_by_key<B, F>(self, key_by: F) -> MinByKeyFuture<Self, Self::Item, F>where Self: Sized, B: Ord, F: FnMut(&Self::Item) -> B,
Returns the element that gives the minimum value with respect to the
specified key function. If several elements are equally minimum,
the first element is returned. If the stream is empty,
None
is returned. Read more§fn max_by_key<B, F>(self, key_by: F) -> MaxByKeyFuture<Self, Self::Item, F>where
Self: Sized,
B: Ord,
F: FnMut(&Self::Item) -> B,
fn max_by_key<B, F>(self, key_by: F) -> MaxByKeyFuture<Self, Self::Item, F>where Self: Sized, B: Ord, F: FnMut(&Self::Item) -> B,
Returns the element that gives the maximum value with respect to the
specified key function. If several elements are equally maximum,
the first element is returned. If the stream is empty,
None
is returned. Read more§fn min_by<F>(self, compare: F) -> MinByFuture<Self, F, Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by<F>(self, compare: F) -> MinByFuture<Self, F, Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
Returns the element that gives the minimum value with respect to the
specified comparison function. If several elements are equally minimum,
the first element is returned. If the stream is empty,
None
is returned. Read more§fn max(self) -> MaxFuture<Self, Self::Item>where
Self: Sized,
Self::Item: Ord,
fn max(self) -> MaxFuture<Self, Self::Item>where Self: Sized, Self::Item: Ord,
Returns the element that gives the maximum value. If several elements are equally maximum,
the first element is returned. If the stream is empty,
None
is returned. Read more§fn min(self) -> MinFuture<Self, Self::Item>where
Self: Sized,
Self::Item: Ord,
fn min(self) -> MinFuture<Self, Self::Item>where Self: Sized, Self::Item: Ord,
Returns the element that gives the minimum value. If several elements are equally minimum,
the first element is returned. If the stream is empty,
None
is returned. Read more§fn max_by<F>(self, compare: F) -> MaxByFuture<Self, F, Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn max_by<F>(self, compare: F) -> MaxByFuture<Self, F, Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
Returns the element that gives the maximum value with respect to the
specified comparison function. If several elements are equally maximum,
the first element is returned. If the stream is empty,
None
is returned. Read more§fn nth(&mut self, n: usize) -> NthFuture<'_, Self>where
Self: Unpin + Sized,
fn nth(&mut self, n: usize) -> NthFuture<'_, Self>where Self: Unpin + Sized,
Returns the nth element of the stream. Read more
§fn all<F>(&mut self, f: F) -> AllFuture<'_, Self, F, Self::Item>where
Self: Unpin + Sized,
F: FnMut(Self::Item) -> bool,
fn all<F>(&mut self, f: F) -> AllFuture<'_, Self, F, Self::Item>where Self: Unpin + Sized, F: FnMut(Self::Item) -> bool,
Tests if every element of the stream matches a predicate. Read more
§fn find<P>(&mut self, p: P) -> FindFuture<'_, Self, P>where
Self: Unpin + Sized,
P: FnMut(&Self::Item) -> bool,
fn find<P>(&mut self, p: P) -> FindFuture<'_, Self, P>where Self: Unpin + Sized, P: FnMut(&Self::Item) -> bool,
Searches for an element in a stream that satisfies a predicate. Read more
§fn find_map<F, B>(&mut self, f: F) -> FindMapFuture<'_, Self, F>where
Self: Unpin + Sized,
F: FnMut(Self::Item) -> Option<B>,
fn find_map<F, B>(&mut self, f: F) -> FindMapFuture<'_, Self, F>where Self: Unpin + Sized, F: FnMut(Self::Item) -> Option<B>,
Applies function to the elements of stream and returns the first non-none result. Read more
§fn fold<B, F>(self, init: B, f: F) -> FoldFuture<Self, F, B>where
Self: Sized,
F: FnMut(B, Self::Item) -> B,
fn fold<B, F>(self, init: B, f: F) -> FoldFuture<Self, F, B>where Self: Sized, F: FnMut(B, Self::Item) -> B,
A combinator that applies a function to every element in a stream
producing a single, final value. Read more
§fn partition<B, F>(self, f: F) -> PartitionFuture<Self, F, B>where
Self: Sized,
F: FnMut(&Self::Item) -> bool,
B: Default + Extend<Self::Item>,
fn partition<B, F>(self, f: F) -> PartitionFuture<Self, F, B>where Self: Sized, F: FnMut(&Self::Item) -> bool, B: Default + Extend<Self::Item>,
A combinator that applies a function to every element in a stream
creating two collections from it. Read more
§fn for_each<F>(self, f: F) -> ForEachFuture<Self, F>where
Self: Sized,
F: FnMut(Self::Item),
fn for_each<F>(self, f: F) -> ForEachFuture<Self, F>where Self: Sized, F: FnMut(Self::Item),
Call a closure on each element of the stream. Read more
§fn any<F>(&mut self, f: F) -> AnyFuture<'_, Self, F, Self::Item>where
Self: Unpin + Sized,
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> AnyFuture<'_, Self, F, Self::Item>where Self: Unpin + Sized, F: FnMut(Self::Item) -> bool,
Tests if any element of the stream matches a predicate. Read more
§fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,
§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,
Combinator that
skip
s elements based on a predicate. Read more§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where Self: Sized,
Creates a combinator that skips the first
n
elements. Read more§fn timeout(self, dur: Duration) -> Timeout<Self>where
Self: Stream + Sized,
fn timeout(self, dur: Duration) -> Timeout<Self>where Self: Stream + Sized,
Await a stream or times out after a duration of time. Read more
§fn try_fold<B, F, T, E>(
&mut self,
init: T,
f: F
) -> TryFoldFuture<'_, Self, F, T>where
Self: Unpin + Sized,
F: FnMut(B, Self::Item) -> Result<T, E>,
fn try_fold<B, F, T, E>( &mut self, init: T, f: F ) -> TryFoldFuture<'_, Self, F, T>where Self: Unpin + Sized, F: FnMut(B, Self::Item) -> Result<T, E>,
A combinator that applies a function as long as it returns successfully, producing a single, final value.
Immediately returns the error when the function returns unsuccessfully. Read more
§fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F>where
Self: Unpin + Sized,
F: FnMut(Self::Item) -> Result<(), E>,
fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F>where Self: Unpin + Sized, F: FnMut(Self::Item) -> Result<(), E>,
Applies a falliable function to each element in a stream, stopping at first error and returning it. Read more
§fn zip<U>(self, other: U) -> Zip<Self, U>where
Self: Sized,
U: Stream,
fn zip<U>(self, other: U) -> Zip<Self, U>where Self: Sized, U: Stream,
‘Zips up’ two streams into a single stream of pairs. Read more
§fn unzip<A, B, FromA, FromB>(self) -> UnzipFuture<Self, FromA, FromB>where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Stream<Item = (A, B)> + Sized,
fn unzip<A, B, FromA, FromB>(self) -> UnzipFuture<Self, FromA, FromB>where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Stream<Item = (A, B)> + Sized,
Converts an stream of pairs into a pair of containers. Read more
§fn collect<'a, B>(self) -> Pin<Box<dyn Future<Output = B> + Send + 'a, Global>>where
Self: Sized + 'a + Send,
B: FromStream<Self::Item>,
Self::Item: Send,
fn collect<'a, B>(self) -> Pin<Box<dyn Future<Output = B> + Send + 'a, Global>>where Self: Sized + 'a + Send, B: FromStream<Self::Item>, Self::Item: Send,
Transforms a stream into a collection. Read more
§fn merge<U>(self, other: U) -> Merge<Self, U>where
Self: Sized,
U: Stream<Item = Self::Item>,
fn merge<U>(self, other: U) -> Merge<Self, U>where Self: Sized, U: Stream<Item = Self::Item>,
Combines multiple streams into a single stream of all their outputs. Read more
§fn partial_cmp<S>(self, other: S) -> PartialCmpFuture<Self, S>where
Self: Sized + Stream,
S: Stream,
Self::Item: PartialOrd<<S as Stream>::Item>,
fn partial_cmp<S>(self, other: S) -> PartialCmpFuture<Self, S>where Self: Sized + Stream, S: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,
Lexicographically compares the elements of this
Stream
with those
of another. Read more§fn position<P>(&mut self, predicate: P) -> PositionFuture<'_, Self, P>where
Self: Unpin + Sized,
P: FnMut(Self::Item) -> bool,
fn position<P>(&mut self, predicate: P) -> PositionFuture<'_, Self, P>where Self: Unpin + Sized, P: FnMut(Self::Item) -> bool,
Searches for an element in a Stream that satisfies a predicate, returning
its index. Read more
§fn cmp<S>(self, other: S) -> CmpFuture<Self, S>where
Self: Sized + Stream,
S: Stream,
Self::Item: Ord,
fn cmp<S>(self, other: S) -> CmpFuture<Self, S>where Self: Sized + Stream, S: Stream, Self::Item: Ord,
Lexicographically compares the elements of this
Stream
with those
of another using ‘Ord’. Read more§fn count(self) -> CountFuture<Self>where
Self: Sized,
fn count(self) -> CountFuture<Self>where Self: Sized,
Counts the number of elements in the stream. Read more
§fn ne<S>(self, other: S) -> NeFuture<Self, S>where
Self: Sized,
S: Stream,
Self::Item: PartialEq<<S as Stream>::Item>,
fn ne<S>(self, other: S) -> NeFuture<Self, S>where Self: Sized, S: Stream, Self::Item: PartialEq<<S as Stream>::Item>,
Determines if the elements of this
Stream
are lexicographically
not equal to those of another. Read more§fn ge<S>(self, other: S) -> GeFuture<Self, S>where
Self: Sized + Stream,
S: Stream,
Self::Item: PartialOrd<<S as Stream>::Item>,
fn ge<S>(self, other: S) -> GeFuture<Self, S>where Self: Sized + Stream, S: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,
Determines if the elements of this
Stream
are lexicographically
greater than or equal to those of another. Read more§fn eq<S>(self, other: S) -> EqFuture<Self, S>where
Self: Sized + Stream,
S: Stream,
Self::Item: PartialEq<<S as Stream>::Item>,
fn eq<S>(self, other: S) -> EqFuture<Self, S>where Self: Sized + Stream, S: Stream, Self::Item: PartialEq<<S as Stream>::Item>,
Determines if the elements of this
Stream
are lexicographically
equal to those of another. Read more§fn gt<S>(self, other: S) -> GtFuture<Self, S>where
Self: Sized + Stream,
S: Stream,
Self::Item: PartialOrd<<S as Stream>::Item>,
fn gt<S>(self, other: S) -> GtFuture<Self, S>where Self: Sized + Stream, S: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,
Determines if the elements of this
Stream
are lexicographically
greater than those of another. Read more§fn le<S>(self, other: S) -> LeFuture<Self, S>where
Self: Sized + Stream,
S: Stream,
Self::Item: PartialOrd<<S as Stream>::Item>,
fn le<S>(self, other: S) -> LeFuture<Self, S>where Self: Sized + Stream, S: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,
Determines if the elements of this
Stream
are lexicographically
less or equal to those of another. Read more§fn lt<S>(self, other: S) -> LtFuture<Self, S>where
Self: Sized + Stream,
S: Stream,
Self::Item: PartialOrd<<S as Stream>::Item>,
fn lt<S>(self, other: S) -> LtFuture<Self, S>where Self: Sized + Stream, S: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,
Determines if the elements of this
Stream
are lexicographically
less than those of another. Read more§impl<S> StreamExt for Swhere
S: Stream + ?Sized,
impl<S> StreamExt for Swhere S: Stream + ?Sized,
§fn next(&mut self) -> NextFuture<'_, Self> ⓘwhere
Self: Unpin,
fn next(&mut self) -> NextFuture<'_, Self> ⓘwhere Self: Unpin,
Retrieves the next item in the stream. Read more
§fn try_next<T, E>(&mut self) -> TryNextFuture<'_, Self> ⓘwhere
Self: Stream<Item = Result<T, E>> + Unpin,
fn try_next<T, E>(&mut self) -> TryNextFuture<'_, Self> ⓘwhere Self: Stream<Item = Result<T, E>> + Unpin,
Retrieves the next item in the stream. Read more
§fn count(self) -> CountFuture<Self> ⓘwhere
Self: Sized,
fn count(self) -> CountFuture<Self> ⓘwhere Self: Sized,
Counts the number of items in the stream. Read more
§fn map<T, F>(self, f: F) -> Map<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> T,
fn map<T, F>(self, f: F) -> Map<Self, F>where Self: Sized, F: FnMut(Self::Item) -> T,
Maps items of the stream to new values using a closure. Read more
§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
Self: Sized,
U: Stream,
F: FnMut(Self::Item) -> U,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where Self: Sized, U: Stream, F: FnMut(Self::Item) -> U,
Maps items to streams and then concatenates them. Read more
§fn flatten(self) -> Flatten<Self>where
Self: Sized,
Self::Item: Stream,
fn flatten(self) -> Flatten<Self>where Self: Sized, Self::Item: Stream,
Concatenates inner streams. Read more
§fn then<F, Fut>(self, f: F) -> Then<Self, F, Fut>where
Self: Sized,
F: FnMut(Self::Item) -> Fut,
Fut: Future,
fn then<F, Fut>(self, f: F) -> Then<Self, F, Fut>where Self: Sized, F: FnMut(Self::Item) -> Fut, Fut: Future,
Maps items of the stream to new values using an async closure. Read more
§fn filter<P>(self, predicate: P) -> Filter<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn filter<P>(self, predicate: P) -> Filter<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,
§fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> Option<T>,
fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F>where Self: Sized, F: FnMut(Self::Item) -> Option<T>,
Filters and maps items of the stream using a closure. Read more
§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where Self: Sized,
Takes only the first
n
items of the stream. Read more§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,
§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where Self: Sized,
Skips the first
n
items of the stream. Read more§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,
§fn chain<U>(self, other: U) -> Chain<Self, U>where
Self: Sized,
U: Stream<Item = Self::Item>,
fn chain<U>(self, other: U) -> Chain<Self, U>where Self: Sized, U: Stream<Item = Self::Item>,
Appends another stream to the end of this one. Read more
§fn cloned<'a, T>(self) -> Cloned<Self>where
Self: Stream<Item = &'a T> + Sized,
T: Clone + 'a,
fn cloned<'a, T>(self) -> Cloned<Self>where Self: Stream<Item = &'a T> + Sized, T: Clone + 'a,
Clones all items. Read more
§fn copied<'a, T>(self) -> Copied<Self>where
Self: Stream<Item = &'a T> + Sized,
T: Copy + 'a,
fn copied<'a, T>(self) -> Copied<Self>where Self: Stream<Item = &'a T> + Sized, T: Copy + 'a,
Copies all items. Read more
§fn collect<C>(self) -> CollectFuture<Self, C> ⓘwhere
Self: Sized,
C: Default + Extend<Self::Item>,
fn collect<C>(self) -> CollectFuture<Self, C> ⓘwhere Self: Sized, C: Default + Extend<Self::Item>,
Collects all items in the stream into a collection. Read more
§fn try_collect<T, E, C>(self) -> TryCollectFuture<Self, C> ⓘwhere
Self: Stream<Item = Result<T, E>> + Sized,
C: Default + Extend<T>,
fn try_collect<T, E, C>(self) -> TryCollectFuture<Self, C> ⓘwhere Self: Stream<Item = Result<T, E>> + Sized, C: Default + Extend<T>,
Collects all items in the fallible stream into a collection. Read more
§fn partition<B, P>(self, predicate: P) -> PartitionFuture<Self, P, B> ⓘwhere
Self: Sized,
B: Default + Extend<Self::Item>,
P: FnMut(&Self::Item) -> bool,
fn partition<B, P>(self, predicate: P) -> PartitionFuture<Self, P, B> ⓘwhere Self: Sized, B: Default + Extend<Self::Item>, P: FnMut(&Self::Item) -> bool,
Partitions items into those for which
predicate
is true
and those for which it is
false
, and then collects them into two collections. Read more§fn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T> ⓘwhere
Self: Sized,
F: FnMut(T, Self::Item) -> T,
fn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T> ⓘwhere Self: Sized, F: FnMut(T, Self::Item) -> T,
Accumulates a computation over the stream. Read more
§fn try_fold<T, E, F, B>(
&mut self,
init: B,
f: F
) -> TryFoldFuture<'_, Self, F, B> ⓘwhere
Self: Stream<Item = Result<T, E>> + Unpin + Sized,
F: FnMut(B, T) -> Result<B, E>,
fn try_fold<T, E, F, B>( &mut self, init: B, f: F ) -> TryFoldFuture<'_, Self, F, B> ⓘwhere Self: Stream<Item = Result<T, E>> + Unpin + Sized, F: FnMut(B, T) -> Result<B, E>,
Accumulates a fallible computation over the stream. Read more
§fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,
Maps items of the stream to new values using a state value and a closure. Read more
§fn cycle(self) -> Cycle<Self>where
Self: Clone + Sized,
fn cycle(self) -> Cycle<Self>where Self: Clone + Sized,
Repeats the stream from beginning to end, forever. Read more
§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where Self: Sized,
Enumerates items, mapping them to
(index, item)
. Read more§fn inspect<F>(self, f: F) -> Inspect<Self, F>where
Self: Sized,
F: FnMut(&Self::Item),
fn inspect<F>(self, f: F) -> Inspect<Self, F>where Self: Sized, F: FnMut(&Self::Item),
Calls a closure on each item and passes it on. Read more
§fn nth(&mut self, n: usize) -> NthFuture<'_, Self> ⓘwhere
Self: Unpin,
fn nth(&mut self, n: usize) -> NthFuture<'_, Self> ⓘwhere Self: Unpin,
Gets the
n
th item of the stream. Read more§fn last(self) -> LastFuture<Self> ⓘwhere
Self: Sized,
fn last(self) -> LastFuture<Self> ⓘwhere Self: Sized,
Returns the last item in the stream. Read more
§fn find<P>(&mut self, predicate: P) -> FindFuture<'_, Self, P> ⓘwhere
Self: Unpin,
P: FnMut(&Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> FindFuture<'_, Self, P> ⓘwhere Self: Unpin, P: FnMut(&Self::Item) -> bool,
§fn find_map<F, B>(&mut self, f: F) -> FindMapFuture<'_, Self, F> ⓘwhere
Self: Unpin,
F: FnMut(Self::Item) -> Option<B>,
fn find_map<F, B>(&mut self, f: F) -> FindMapFuture<'_, Self, F> ⓘwhere Self: Unpin, F: FnMut(Self::Item) -> Option<B>,
§fn position<P>(&mut self, predicate: P) -> PositionFuture<'_, Self, P> ⓘwhere
Self: Unpin,
P: FnMut(Self::Item) -> bool,
fn position<P>(&mut self, predicate: P) -> PositionFuture<'_, Self, P> ⓘwhere Self: Unpin, P: FnMut(Self::Item) -> bool,
§fn all<P>(&mut self, predicate: P) -> AllFuture<'_, Self, P> ⓘwhere
Self: Unpin,
P: FnMut(Self::Item) -> bool,
fn all<P>(&mut self, predicate: P) -> AllFuture<'_, Self, P> ⓘwhere Self: Unpin, P: FnMut(Self::Item) -> bool,
§fn any<P>(&mut self, predicate: P) -> AnyFuture<'_, Self, P> ⓘwhere
Self: Unpin,
P: FnMut(Self::Item) -> bool,
fn any<P>(&mut self, predicate: P) -> AnyFuture<'_, Self, P> ⓘwhere Self: Unpin, P: FnMut(Self::Item) -> bool,
§fn for_each<F>(self, f: F) -> ForEachFuture<Self, F> ⓘwhere
Self: Sized,
F: FnMut(Self::Item),
fn for_each<F>(self, f: F) -> ForEachFuture<Self, F> ⓘwhere Self: Sized, F: FnMut(Self::Item),
Calls a closure on each item of the stream. Read more
§fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F> ⓘwhere
Self: Unpin,
F: FnMut(Self::Item) -> Result<(), E>,
fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F> ⓘwhere Self: Unpin, F: FnMut(Self::Item) -> Result<(), E>,
Calls a fallible closure on each item of the stream, stopping on first error. Read more
§fn zip<U>(self, other: U) -> Zip<Self, U>where
Self: Sized,
U: Stream,
fn zip<U>(self, other: U) -> Zip<Self, U>where Self: Sized, U: Stream,
Zips up two streams into a single stream of pairs. Read more
§fn unzip<A, B, FromA, FromB>(self) -> UnzipFuture<Self, FromA, FromB> ⓘwhere
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Stream<Item = (A, B)> + Sized,
fn unzip<A, B, FromA, FromB>(self) -> UnzipFuture<Self, FromA, FromB> ⓘwhere FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Stream<Item = (A, B)> + Sized,
Collects a stream of pairs into a pair of collections. Read more
§fn race<S>(self, other: S) -> Race<Self, S>where
Self: Sized,
S: Stream<Item = Self::Item>,
fn race<S>(self, other: S) -> Race<Self, S>where Self: Sized, S: Stream<Item = Self::Item>,
Merges with
other
stream, with no preference for either stream when both are ready. Read moresource§impl<St> StreamExt for Stwhere
St: Stream + ?Sized,
impl<St> StreamExt for Stwhere St: Stream + ?Sized,
source§fn next(&mut self) -> Next<'_, Self>where
Self: Unpin,
fn next(&mut self) -> Next<'_, Self>where Self: Unpin,
Consumes and returns the next value in the stream or
None
if the
stream is finished. Read moresource§fn try_next<T, E>(&mut self) -> TryNext<'_, Self>where
Self: Stream<Item = Result<T, E>> + Unpin,
fn try_next<T, E>(&mut self) -> TryNext<'_, Self>where Self: Stream<Item = Result<T, E>> + Unpin,
Consumes and returns the next item in the stream. If an error is
encountered before the next item, the error is returned instead. Read more
source§fn map<T, F>(self, f: F) -> Map<Self, F>where
F: FnMut(Self::Item) -> T,
Self: Sized,
fn map<T, F>(self, f: F) -> Map<Self, F>where F: FnMut(Self::Item) -> T, Self: Sized,
Maps this stream’s items to a different type, returning a new stream of
the resulting type. Read more
source§fn map_while<T, F>(self, f: F) -> MapWhile<Self, F>where
F: FnMut(Self::Item) -> Option<T>,
Self: Sized,
fn map_while<T, F>(self, f: F) -> MapWhile<Self, F>where F: FnMut(Self::Item) -> Option<T>, Self: Sized,
Map this stream’s items to a different type for as long as determined by
the provided closure. A stream of the target type will be returned,
which will yield elements until the closure returns
None
. Read moresource§fn then<F, Fut>(self, f: F) -> Then<Self, Fut, F>where
F: FnMut(Self::Item) -> Fut,
Fut: Future,
Self: Sized,
fn then<F, Fut>(self, f: F) -> Then<Self, Fut, F>where F: FnMut(Self::Item) -> Fut, Fut: Future, Self: Sized,
Maps this stream’s items asynchronously to a different type, returning a
new stream of the resulting type. Read more
source§fn merge<U>(self, other: U) -> Merge<Self, U>where
U: Stream<Item = Self::Item>,
Self: Sized,
fn merge<U>(self, other: U) -> Merge<Self, U>where U: Stream<Item = Self::Item>, Self: Sized,
Combine two streams into one by interleaving the output of both as it
is produced. Read more
source§fn filter<F>(self, f: F) -> Filter<Self, F>where
F: FnMut(&Self::Item) -> bool,
Self: Sized,
fn filter<F>(self, f: F) -> Filter<Self, F>where F: FnMut(&Self::Item) -> bool, Self: Sized,
Filters the values produced by this stream according to the provided
predicate. Read more
source§fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F>where
F: FnMut(Self::Item) -> Option<T>,
Self: Sized,
fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F>where F: FnMut(Self::Item) -> Option<T>, Self: Sized,
Filters the values produced by this stream while simultaneously mapping
them to a different type according to the provided closure. Read more
source§fn fuse(self) -> Fuse<Self>where
Self: Sized,
fn fuse(self) -> Fuse<Self>where Self: Sized,
Creates a stream which ends after the first
None
. Read moresource§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where Self: Sized,
Creates a new stream of at most
n
items of the underlying stream. Read moresource§fn take_while<F>(self, f: F) -> TakeWhile<Self, F>where
F: FnMut(&Self::Item) -> bool,
Self: Sized,
fn take_while<F>(self, f: F) -> TakeWhile<Self, F>where F: FnMut(&Self::Item) -> bool, Self: Sized,
Take elements from this stream while the provided predicate
resolves to
true
. Read moresource§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where Self: Sized,
Creates a new stream that will skip the
n
first items of the
underlying stream. Read moresource§fn skip_while<F>(self, f: F) -> SkipWhile<Self, F>where
F: FnMut(&Self::Item) -> bool,
Self: Sized,
fn skip_while<F>(self, f: F) -> SkipWhile<Self, F>where F: FnMut(&Self::Item) -> bool, Self: Sized,
Skip elements from the underlying stream while the provided predicate
resolves to
true
. Read moresource§fn all<F>(&mut self, f: F) -> AllFuture<'_, Self, F>where
Self: Unpin,
F: FnMut(Self::Item) -> bool,
fn all<F>(&mut self, f: F) -> AllFuture<'_, Self, F>where Self: Unpin, F: FnMut(Self::Item) -> bool,
Tests if every element of the stream matches a predicate. Read more
source§fn any<F>(&mut self, f: F) -> AnyFuture<'_, Self, F>where
Self: Unpin,
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> AnyFuture<'_, Self, F>where Self: Unpin, F: FnMut(Self::Item) -> bool,
Tests if any element of the stream matches a predicate. Read more
source§fn chain<U>(self, other: U) -> Chain<Self, U>where
U: Stream<Item = Self::Item>,
Self: Sized,
fn chain<U>(self, other: U) -> Chain<Self, U>where U: Stream<Item = Self::Item>, Self: Sized,
Combine two streams into one by first returning all values from the
first stream then all values from the second stream. Read more
source§fn fold<B, F>(self, init: B, f: F) -> FoldFuture<Self, B, F>where
Self: Sized,
F: FnMut(B, Self::Item) -> B,
fn fold<B, F>(self, init: B, f: F) -> FoldFuture<Self, B, F>where Self: Sized, F: FnMut(B, Self::Item) -> B,
A combinator that applies a function to every element in a stream
producing a single, final value. Read more
source§fn collect<T>(self) -> Collect<Self, T>where
T: FromStream<Self::Item>,
Self: Sized,
fn collect<T>(self) -> Collect<Self, T>where T: FromStream<Self::Item>, Self: Sized,
Drain stream pushing all emitted values into a collection. Read more
source§fn timeout(self, duration: Duration) -> Timeout<Self>where
Self: Sized,
fn timeout(self, duration: Duration) -> Timeout<Self>where Self: Sized,
Applies a per-item timeout to the passed stream. Read more
source§fn timeout_repeating(self, interval: Interval) -> TimeoutRepeating<Self>where
Self: Sized,
fn timeout_repeating(self, interval: Interval) -> TimeoutRepeating<Self>where Self: Sized,
Applies a per-item timeout to the passed stream. Read more
§impl<'a, S> StreamRateLimitExt<'a> for Swhere
S: Stream,
impl<'a, S> StreamRateLimitExt<'a> for Swhere S: Stream,
§fn ratelimit_stream<D, C>(
self,
limiter: &'a RateLimiter<NotKeyed, D, C>
) -> RatelimitedStream<'a, S, D, C>where
D: DirectStateStore,
C: Clock + ReasonablyRealtime,
fn ratelimit_stream<D, C>( self, limiter: &'a RateLimiter<NotKeyed, D, C> ) -> RatelimitedStream<'a, S, D, C>where D: DirectStateStore, C: Clock + ReasonablyRealtime,
Limits the rate at which the stream produces items. Read more
§fn ratelimit_stream_with_jitter<D, C>(
self,
limiter: &'a RateLimiter<NotKeyed, D, C>,
jitter: Jitter
) -> RatelimitedStream<'a, S, D, C>where
D: DirectStateStore,
C: Clock + ReasonablyRealtime,
fn ratelimit_stream_with_jitter<D, C>( self, limiter: &'a RateLimiter<NotKeyed, D, C>, jitter: Jitter ) -> RatelimitedStream<'a, S, D, C>where D: DirectStateStore, C: Clock + ReasonablyRealtime,
Limits the rate at which the stream produces items, with a randomized wait period. Read more
§impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SPwhere SS: SubsetOf<SP>,
§fn to_subset(&self) -> Option<SS>
fn to_subset(&self) -> Option<SS>
The inverse inclusion map: attempts to construct
self
from the equivalent element of its
superset. Read more§fn is_in_subset(&self) -> bool
fn is_in_subset(&self) -> bool
Checks if
self
is actually part of its subset T
(and can be converted to it).§fn to_subset_unchecked(&self) -> SS
fn to_subset_unchecked(&self) -> SS
Use with care! Same as
self.to_subset
but without any property checks. Always succeeds.§fn from_subset(element: &SS) -> SP
fn from_subset(element: &SS) -> SP
The inclusion map: converts
self
to the equivalent element of its superset.§impl<Fut> TryFutureExt for Futwhere
Fut: TryFuture + ?Sized,
impl<Fut> TryFutureExt for Futwhere Fut: TryFuture + ?Sized,
§fn flatten_sink<Item>(self) -> FlattenSink<Self, Self::Ok>where
Self::Ok: Sink<Item, Error = Self::Error>,
Self: Sized,
fn flatten_sink<Item>(self) -> FlattenSink<Self, Self::Ok>where Self::Ok: Sink<Item, Error = Self::Error>, Self: Sized,
§fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> ⓘwhere
F: FnOnce(Self::Ok) -> T,
Self: Sized,
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> ⓘwhere F: FnOnce(Self::Ok) -> T, Self: Sized,
Maps this future’s success value to a different value. Read more
§fn map_ok_or_else<T, E, F>(self, e: E, f: F) -> MapOkOrElse<Self, F, E> ⓘwhere
F: FnOnce(Self::Ok) -> T,
E: FnOnce(Self::Error) -> T,
Self: Sized,
fn map_ok_or_else<T, E, F>(self, e: E, f: F) -> MapOkOrElse<Self, F, E> ⓘwhere F: FnOnce(Self::Ok) -> T, E: FnOnce(Self::Error) -> T, Self: Sized,
Maps this future’s success value to a different value, and permits for error handling resulting in the same type. Read more
§fn map_err<E, F>(self, f: F) -> MapErr<Self, F> ⓘwhere
F: FnOnce(Self::Error) -> E,
Self: Sized,
fn map_err<E, F>(self, f: F) -> MapErr<Self, F> ⓘwhere F: FnOnce(Self::Error) -> E, Self: Sized,
Maps this future’s error value to a different value. Read more
§fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> ⓘwhere
F: FnOnce(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
Self: Sized,
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> ⓘwhere F: FnOnce(Self::Ok) -> Fut, Fut: TryFuture<Error = Self::Error>, Self: Sized,
Executes another future after this one resolves successfully. The
success value is passed to a closure to create this subsequent future. Read more
§fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> ⓘwhere
F: FnOnce(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
Self: Sized,
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> ⓘwhere F: FnOnce(Self::Error) -> Fut, Fut: TryFuture<Ok = Self::Ok>, Self: Sized,
Executes another future if this one resolves to an error. The
error value is passed to a closure to create this subsequent future. Read more
§fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> ⓘwhere
F: FnOnce(&Self::Ok),
Self: Sized,
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> ⓘwhere F: FnOnce(&Self::Ok), Self: Sized,
Do something with the success value of a future before passing it on. Read more
§fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> ⓘwhere
F: FnOnce(&Self::Error),
Self: Sized,
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> ⓘwhere F: FnOnce(&Self::Error), Self: Sized,
Do something with the error value of a future before passing it on. Read more
§fn try_flatten(self) -> TryFlatten<Self, Self::Ok> ⓘwhere
Self::Ok: TryFuture<Error = Self::Error>,
Self: Sized,
fn try_flatten(self) -> TryFlatten<Self, Self::Ok> ⓘwhere Self::Ok: TryFuture<Error = Self::Error>, Self: Sized,
Flatten the execution of this future when the successful result of this
future is another future. Read more
§fn try_flatten_stream(self) -> TryFlattenStream<Self>where
Self::Ok: TryStream<Error = Self::Error>,
Self: Sized,
fn try_flatten_stream(self) -> TryFlattenStream<Self>where Self::Ok: TryStream<Error = Self::Error>, Self: Sized,
Flatten the execution of this future when the successful result of this
future is a stream. Read more
§fn unwrap_or_else<F>(self, f: F) -> UnwrapOrElse<Self, F> ⓘwhere
Self: Sized,
F: FnOnce(Self::Error) -> Self::Ok,
fn unwrap_or_else<F>(self, f: F) -> UnwrapOrElse<Self, F> ⓘwhere Self: Sized, F: FnOnce(Self::Error) -> Self::Ok,
§fn into_future(self) -> IntoFuture<Self> ⓘwhere
Self: Sized,
fn into_future(self) -> IntoFuture<Self> ⓘwhere Self: Sized,
§fn try_poll_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<Self::Ok, Self::Error>>where
Self: Unpin,
fn try_poll_unpin( &mut self, cx: &mut Context<'_> ) -> Poll<Result<Self::Ok, Self::Error>>where Self: Unpin,
A convenience method for calling
TryFuture::try_poll
on Unpin
future types.§impl<S> TryStreamExt for Swhere
S: TryStream + ?Sized,
impl<S> TryStreamExt for Swhere S: TryStream + ?Sized,
§fn err_into<E>(self) -> ErrInto<Self, E>where
Self: Sized,
Self::Error: Into<E>,
fn err_into<E>(self) -> ErrInto<Self, E>where Self: Sized, Self::Error: Into<E>,
Wraps the current stream in a new stream which converts the error type
into the one provided. Read more
§fn map_ok<T, F>(self, f: F) -> MapOk<Self, F>where
Self: Sized,
F: FnMut(Self::Ok) -> T,
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F>where Self: Sized, F: FnMut(Self::Ok) -> T,
Wraps the current stream in a new stream which maps the success value
using the provided closure. Read more
§fn map_err<E, F>(self, f: F) -> MapErr<Self, F>where
Self: Sized,
F: FnMut(Self::Error) -> E,
fn map_err<E, F>(self, f: F) -> MapErr<Self, F>where Self: Sized, F: FnMut(Self::Error) -> E,
Wraps the current stream in a new stream which maps the error value
using the provided closure. Read more
§fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F>where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
Self: Sized,
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F>where F: FnMut(Self::Ok) -> Fut, Fut: TryFuture<Error = Self::Error>, Self: Sized,
Chain on a computation for when a value is ready, passing the successful
results to the provided closure
f
. Read more§fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F>where
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
Self: Sized,
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F>where F: FnMut(Self::Error) -> Fut, Fut: TryFuture<Ok = Self::Ok>, Self: Sized,
Chain on a computation for when an error happens, passing the
erroneous result to the provided closure
f
. Read more§fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F>where
F: FnMut(&Self::Ok),
Self: Sized,
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F>where F: FnMut(&Self::Ok), Self: Sized,
Do something with the success value of this stream, afterwards passing
it on. Read more
§fn inspect_err<F>(self, f: F) -> InspectErr<Self, F>where
F: FnMut(&Self::Error),
Self: Sized,
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F>where F: FnMut(&Self::Error), Self: Sized,
Do something with the error value of this stream, afterwards passing it on. Read more
§fn into_stream(self) -> IntoStream<Self>where
Self: Sized,
fn into_stream(self) -> IntoStream<Self>where Self: Sized,
§fn try_next(&mut self) -> TryNext<'_, Self> ⓘwhere
Self: Unpin,
fn try_next(&mut self) -> TryNext<'_, Self> ⓘwhere Self: Unpin,
Creates a future that attempts to resolve the next item in the stream.
If an error is encountered before the next item, the error is returned
instead. Read more
§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>,
Self: Sized,
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>, Self: Sized,
Attempts to run this stream to completion, executing the provided
asynchronous closure for each element on the stream. Read more
§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>,
Self: Sized,
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>, Self: Sized,
Skip elements on this stream while the provided asynchronous predicate
resolves to
true
. Read more§fn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F>where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
Self: Sized,
fn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F>where F: FnMut(&Self::Ok) -> Fut, Fut: TryFuture<Ok = bool, Error = Self::Error>, Self: Sized,
Take elements on this stream while the provided asynchronous predicate
resolves to
true
. Read more§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>>,
Self: Sized,
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>>, Self: Sized,
Attempts to run this stream to completion, executing the provided asynchronous
closure for each element on the stream concurrently as elements become
available, exiting as soon as an error occurs. Read more
§fn try_collect<C>(self) -> TryCollect<Self, C> ⓘwhere
C: Default + Extend<Self::Ok>,
Self: Sized,
fn try_collect<C>(self) -> TryCollect<Self, C> ⓘwhere C: Default + Extend<Self::Ok>, Self: Sized,
Attempt to transform a stream into a collection,
returning a future representing the result of that computation. Read more
§fn try_chunks(self, capacity: usize) -> TryChunks<Self>where
Self: Sized,
fn try_chunks(self, capacity: usize) -> TryChunks<Self>where Self: Sized,
An adaptor for chunking up successful items of the stream inside a vector. Read more
§fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F>where
Fut: Future<Output = bool>,
F: FnMut(&Self::Ok) -> Fut,
Self: Sized,
fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F>where Fut: Future<Output = bool>, F: FnMut(&Self::Ok) -> Fut, Self: Sized,
Attempt to filter the values produced by this stream according to the
provided asynchronous closure. Read more
§fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F>where
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
F: FnMut(Self::Ok) -> Fut,
Self: Sized,
fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F>where Fut: TryFuture<Ok = Option<T>, Error = Self::Error>, F: FnMut(Self::Ok) -> Fut, Self: Sized,
Attempt to filter the values produced by this stream while
simultaneously mapping them to a different type according to the
provided asynchronous closure. Read more
§fn try_flatten_unordered(
self,
limit: impl Into<Option<usize>>
) -> TryFlattenUnordered<Self>where
Self::Ok: TryStream + Unpin,
<Self::Ok as TryStream>::Error: From<Self::Error>,
Self: Sized,
fn try_flatten_unordered( self, limit: impl Into<Option<usize>> ) -> TryFlattenUnordered<Self>where Self::Ok: TryStream + Unpin, <Self::Ok as TryStream>::Error: From<Self::Error>, Self: Sized,
Flattens a stream of streams into just one continuous stream. Produced streams
will be polled concurrently and any errors will be passed through without looking at them.
If the underlying base stream returns an error, it will be immediately propagated. Read more
§fn try_flatten(self) -> TryFlatten<Self>where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
Self: Sized,
fn try_flatten(self) -> TryFlatten<Self>where Self::Ok: TryStream, <Self::Ok as TryStream>::Error: From<Self::Error>, Self: Sized,
Flattens a stream of streams into just one continuous stream. Read more
§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>,
Self: Sized,
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>, Self: Sized,
Attempt to execute an accumulating asynchronous computation over a
stream, collecting all the values into one final result. Read more
§fn try_concat(self) -> TryConcat<Self> ⓘwhere
Self: Sized,
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item> + IntoIterator + Default,
fn try_concat(self) -> TryConcat<Self> ⓘwhere Self: Sized, Self::Ok: Extend<<Self::Ok as IntoIterator>::Item> + IntoIterator + Default,
Attempt to concatenate all items of a stream into a single
extendable destination, returning a future representing the end result. Read more
§fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self>where
Self::Ok: TryFuture<Error = Self::Error>,
Self: Sized,
fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self>where Self::Ok: TryFuture<Error = Self::Error>, Self: Sized,
Attempt to execute several futures from a stream concurrently (unordered). Read more
§fn try_buffered(self, n: usize) -> TryBuffered<Self>where
Self::Ok: TryFuture<Error = Self::Error>,
Self: Sized,
fn try_buffered(self, n: usize) -> TryBuffered<Self>where Self::Ok: TryFuture<Error = Self::Error>, Self: Sized,
Attempt to execute several futures from a stream concurrently. Read more
§fn try_poll_next_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Result<Self::Ok, Self::Error>>>where
Self: Unpin,
fn try_poll_next_unpin( &mut self, cx: &mut Context<'_> ) -> Poll<Option<Result<Self::Ok, Self::Error>>>where Self: Unpin,
A convenience method for calling
TryStream::try_poll_next
on Unpin
stream types.§fn into_async_read(self) -> IntoAsyncRead<Self>where
Self: Sized + TryStreamExt<Error = Error>,
Self::Ok: AsRef<[u8]>,
fn into_async_read(self) -> IntoAsyncRead<Self>where Self: Sized + TryStreamExt<Error = Error>, Self::Ok: AsRef<[u8]>,
Adapter that converts this stream into an
AsyncBufRead
. Read more§impl<T> Upcastable for Twhere
T: Any + Send + Sync + 'static,
impl<T> Upcastable for Twhere T: Any + Send + Sync + 'static,
§fn upcast_any_ref(&self) -> &(dyn Any + 'static)
fn upcast_any_ref(&self) -> &(dyn Any + 'static)
upcast ref
§fn upcast_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn upcast_any_mut(&mut self) -> &mut (dyn Any + 'static)
upcast mut ref
source§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
source§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘwhere
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘwhere S: Into<Dispatch>,
source§fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ
fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ
source§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
source§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘwhere
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘwhere S: Into<Dispatch>,
source§fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ
fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ
§impl<T> WriteExt for Twhere
T: AsyncWrite + ?Sized,
impl<T> WriteExt for Twhere T: AsyncWrite + ?Sized,
§fn write<'a>(&'a mut self, buf: &'a [u8]) -> WriteFuture<'a, Self>where
Self: Unpin,
fn write<'a>(&'a mut self, buf: &'a [u8]) -> WriteFuture<'a, Self>where Self: Unpin,
Writes some bytes into the byte stream. Read more
§fn flush(&mut self) -> FlushFuture<'_, Self>where
Self: Unpin,
fn flush(&mut self) -> FlushFuture<'_, Self>where Self: Unpin,
Flushes the stream to ensure that all buffered contents reach their destination. Read more