[−][src]Struct ntex::rt::net::TcpListener
A TCP socket server, listening for connections.
You can accept a new connection by using the accept
method. Alternatively TcpListener
implements the Stream
trait, which allows you to use the listener in places that want a
stream. The stream will never return None
and will also not yield the peer's SocketAddr
structure. Iterating over
it is equivalent to calling accept in a loop.
Errors
Note that accepting a connection can lead to various errors and not all of them are necessarily fatal ‒ for example having too many open file descriptors or the other side closing the connection while it waits in an accept queue. These would terminate the stream if not handled in any way.
Examples
Using accept
:
use tokio::net::TcpListener; use std::io; async fn process_socket<T>(socket: T) { // do work with socket here } #[tokio::main] async fn main() -> io::Result<()> { let mut listener = TcpListener::bind("127.0.0.1:8080").await?; loop { let (socket, _) = listener.accept().await?; process_socket(socket).await; } }
Using impl Stream
:
use tokio::{net::TcpListener, stream::StreamExt}; #[tokio::main] async fn main() { let mut listener = TcpListener::bind("127.0.0.1:8080").await.unwrap(); while let Some(stream) = listener.next().await { match stream { Ok(stream) => { println!("new client!"); } Err(e) => { /* connection failed */ } } } }
Implementations
impl TcpListener
[src]
pub async fn bind<A>(addr: A) -> Result<TcpListener, Error> where
A: ToSocketAddrs,
[src]
A: ToSocketAddrs,
Creates a new TcpListener, which will be bound to the specified address.
The returned listener is ready for accepting connections.
Binding with a port number of 0 will request that the OS assigns a port
to this listener. The port allocated can be queried via the local_addr
method.
The address type can be any implementor of the ToSocketAddrs
trait.
Note that strings only implement this trait when the dns
feature
is enabled, as strings may contain domain names that need to be resolved.
If addr
yields multiple addresses, bind will be attempted with each of
the addresses until one succeeds and returns the listener. If none of
the addresses succeed in creating a listener, the error returned from
the last attempt (the last address) is returned.
This function sets the SO_REUSEADDR
option on the socket.
Examples
use tokio::net::TcpListener; use std::io; #[tokio::main] async fn main() -> io::Result<()> { let listener = TcpListener::bind("127.0.0.1:2345").await?; // use the listener Ok(()) }
Without the dns
feature:
use tokio::net::TcpListener; use std::net::Ipv4Addr; use std::io; #[tokio::main] async fn main() -> io::Result<()> { let listener = TcpListener::bind((Ipv4Addr::new(127, 0, 0, 1), 2345)).await?; // use the listener Ok(()) }
pub async fn accept(&'_ mut self) -> Result<(TcpStream, SocketAddr), Error>
[src]
Accepts a new incoming connection from this listener.
This function will yield once a new TCP connection is established. When
established, the corresponding TcpStream
and the remote peer's
address will be returned.
Examples
use tokio::net::TcpListener; use std::io; #[tokio::main] async fn main() -> io::Result<()> { let mut listener = TcpListener::bind("127.0.0.1:8080").await?; match listener.accept().await { Ok((_socket, addr)) => println!("new client: {:?}", addr), Err(e) => println!("couldn't get client: {:?}", e), } Ok(()) }
pub fn poll_accept(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(TcpStream, SocketAddr), Error>>
[src]
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(TcpStream, SocketAddr), Error>>
Polls to accept a new incoming connection to this listener.
If there is no connection to accept, Poll::Pending
is returned and
the current task will be notified by a waker.
pub fn from_std(listener: TcpListener) -> Result<TcpListener, Error>
[src]
Creates a new TCP listener from the standard library's TCP listener.
This method can be used when the Handle::tcp_listen
method isn't
sufficient because perhaps some more configuration is needed in terms of
before the calls to bind
and listen
.
This API is typically paired with the net2
crate and the TcpBuilder
type to build up and customize a listener before it's shipped off to the
backing event loop. This allows configuration of options like
SO_REUSEPORT
, binding to multiple addresses, etc.
The addr
argument here is one of the addresses that listener
is
bound to and the listener will only be guaranteed to accept connections
of the same address type currently.
The platform specific behavior of this function looks like:
-
On Unix, the socket is placed into nonblocking mode and connections can be accepted as normal
-
On Windows, the address is stored internally and all future accepts will only be for the same IP version as
addr
specified. That is, ifaddr
is an IPv4 address then all sockets accepted will be IPv4 as well (same for IPv6).
Examples
use std::error::Error; use tokio::net::TcpListener; #[tokio::main] async fn main() -> Result<(), Box<dyn Error>> { let std_listener = std::net::TcpListener::bind("127.0.0.1:0")?; let listener = TcpListener::from_std(std_listener)?; Ok(()) }
Panics
This function panics if thread-local runtime is not set.
The runtime is usually set implicitly when this function is called
from a future driven by a tokio runtime, otherwise runtime can be set
explicitly with Handle::enter
function.
pub fn local_addr(&self) -> Result<SocketAddr, Error>
[src]
Returns the local address that this listener is bound to.
This can be useful, for example, when binding to port 0 to figure out which port was actually bound.
Examples
use tokio::net::TcpListener; use std::io; use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4}; #[tokio::main] async fn main() -> io::Result<()> { let listener = TcpListener::bind("127.0.0.1:8080").await?; assert_eq!(listener.local_addr()?, SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080))); Ok(()) }
pub fn incoming(&mut self) -> Incoming<'_>
[src]
Returns a stream over the connections being received on this listener.
Note that TcpListener
also directly implements Stream
.
The returned stream will never return None
and will also not yield the
peer's SocketAddr
structure. Iterating over it is equivalent to
calling accept in a loop.
Errors
Note that accepting a connection can lead to various errors and not all of them are necessarily fatal ‒ for example having too many open file descriptors or the other side closing the connection while it waits in an accept queue. These would terminate the stream if not handled in any way.
Examples
use tokio::{net::TcpListener, stream::StreamExt}; #[tokio::main] async fn main() { let mut listener = TcpListener::bind("127.0.0.1:8080").await.unwrap(); let mut incoming = listener.incoming(); while let Some(stream) = incoming.next().await { match stream { Ok(stream) => { println!("new client!"); } Err(e) => { /* connection failed */ } } } }
pub fn ttl(&self) -> Result<u32, Error>
[src]
Gets the value of the IP_TTL
option for this socket.
For more information about this option, see set_ttl
.
Examples
use tokio::net::TcpListener; use std::io; #[tokio::main] async fn main() -> io::Result<()> { let listener = TcpListener::bind("127.0.0.1:0").await?; listener.set_ttl(100).expect("could not set TTL"); assert_eq!(listener.ttl()?, 100); Ok(()) }
pub fn set_ttl(&self, ttl: u32) -> Result<(), Error>
[src]
Sets the value for the IP_TTL
option on this socket.
This value sets the time-to-live field that is used in every packet sent from this socket.
Examples
use tokio::net::TcpListener; use std::io; #[tokio::main] async fn main() -> io::Result<()> { let listener = TcpListener::bind("127.0.0.1:0").await?; listener.set_ttl(100).expect("could not set TTL"); Ok(()) }
Trait Implementations
impl AsRawFd for TcpListener
[src]
impl Debug for TcpListener
[src]
impl Stream for TcpListener
[src]
type Item = Result<TcpStream, Error>
Values yielded by the stream.
pub fn poll_next(
self: Pin<&mut TcpListener>,
cx: &mut Context<'_>
) -> Poll<Option<<TcpListener as Stream>::Item>>
[src]
self: Pin<&mut TcpListener>,
cx: &mut Context<'_>
) -> Poll<Option<<TcpListener as Stream>::Item>>
pub fn size_hint(&self) -> (usize, Option<usize>)
impl TryFrom<TcpListener> for TcpListener
[src]
type Error = Error
The type returned in the event of a conversion error.
pub fn try_from(
stream: TcpListener
) -> Result<TcpListener, <TcpListener as TryFrom<TcpListener>>::Error>
[src]
stream: TcpListener
) -> Result<TcpListener, <TcpListener as TryFrom<TcpListener>>::Error>
Consumes stream, returning the tokio I/O object.
This is equivalent to
TcpListener::from_std(stream)
.
Auto Trait Implementations
impl !RefUnwindSafe for TcpListener
[src]
impl Send for TcpListener
[src]
impl Sync for TcpListener
[src]
impl Unpin for TcpListener
[src]
impl !UnwindSafe for TcpListener
[src]
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T> Instrument for T
[src]
pub fn instrument(self, span: Span) -> Instrumented<Self>
[src]
pub fn in_current_span(self) -> Instrumented<Self>
[src]
impl<T> Instrument for T
[src]
pub fn instrument(self, span: Span) -> Instrumented<Self>
[src]
pub fn in_current_span(self) -> Instrumented<Self>
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> StreamExt for T where
T: Stream + ?Sized,
T: Stream + ?Sized,
pub fn next(&mut self) -> Next<'_, Self> where
Self: Unpin,
Self: Unpin,
pub fn into_future(self) -> StreamFuture<Self> where
Self: Unpin,
Self: Unpin,
pub fn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T,
F: FnMut(Self::Item) -> T,
pub fn enumerate(self) -> Enumerate<Self>
pub fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
pub fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>,
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>,
pub fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future,
F: FnMut(Self::Item) -> Fut,
Fut: Future,
pub fn collect<C>(self) -> Collect<Self, C> where
C: Default + Extend<Self::Item>,
C: Default + Extend<Self::Item>,
pub fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB> where
Self: Stream<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Stream<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
pub fn concat(self) -> Concat<Self> where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
pub fn cycle(self) -> Cycle<Self> where
Self: Clone,
Self: Clone,
pub 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>,
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>,
pub fn flatten(self) -> Flatten<Self> where
Self::Item: Stream,
Self::Item: Stream,
pub fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
U: Stream,
F: FnMut(Self::Item) -> U,
U: Stream,
F: FnMut(Self::Item) -> U,
pub 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>>,
F: FnMut(&mut S, Self::Item) -> Fut,
Fut: Future<Output = Option<B>>,
pub fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
pub fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
pub fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut> where
Fut: Future,
Fut: Future,
pub fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
pub 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,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
pub fn take(self, n: usize) -> Take<Self>
pub fn skip(self, n: usize) -> Skip<Self>
pub fn fuse(self) -> Fuse<Self>
pub fn by_ref(&mut self) -> &mut Self
pub fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
Self: UnwindSafe,
pub fn boxed<'a>(
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send, Global>> where
Self: Send + 'a,
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send, Global>> where
Self: Send + 'a,
pub fn boxed_local<'a>(
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>> where
Self: 'a,
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>> where
Self: 'a,
pub fn buffered(self, n: usize) -> Buffered<Self> where
Self::Item: Future,
Self::Item: Future,
pub fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where
Self::Item: Future,
Self::Item: Future,
pub fn zip<St>(self, other: St) -> Zip<Self, St> where
St: Stream,
St: Stream,
pub fn chain<St>(self, other: St) -> Chain<Self, St> where
St: Stream<Item = Self::Item>,
St: Stream<Item = Self::Item>,
pub fn peekable(self) -> Peekable<Self>
pub fn chunks(self, capacity: usize) -> Chunks<Self>
pub fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>
pub fn forward<S>(self, sink: S) -> Forward<Self, S> where
Self: TryStream,
S: Sink<Self::Ok, Error = Self::Error>,
Self: TryStream,
S: Sink<Self::Ok, Error = Self::Error>,
pub fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where
Self: Sink<Item>,
Self: Sink<Item>,
pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
F: FnMut(&Self::Item),
pub fn left_stream<B>(self) -> Either<Self, B> where
B: Stream<Item = Self::Item>,
B: Stream<Item = Self::Item>,
pub fn right_stream<B>(self) -> Either<B, Self> where
B: Stream<Item = Self::Item>,
B: Stream<Item = Self::Item>,
pub fn poll_next_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Self::Item>> where
Self: Unpin,
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Self::Item>> where
Self: Unpin,
pub fn select_next_some(&mut self) -> SelectNextSome<'_, Self> where
Self: Unpin + FusedStream,
Self: Unpin + FusedStream,
impl<St> StreamExt for St where
St: Stream + ?Sized,
[src]
St: Stream + ?Sized,
pub fn next(&mut self) -> Next<'_, Self> where
Self: Unpin,
[src]
Self: Unpin,
pub fn try_next<T, E>(&mut self) -> TryNext<'_, Self> where
Self: Stream<Item = Result<T, E>> + Unpin,
[src]
Self: Stream<Item = Result<T, E>> + Unpin,
pub fn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T,
[src]
F: FnMut(Self::Item) -> T,
pub fn merge<U>(self, other: U) -> Merge<Self, U> where
U: Stream<Item = Self::Item>,
[src]
U: Stream<Item = Self::Item>,
pub fn filter<F>(self, f: F) -> Filter<Self, F> where
F: FnMut(&Self::Item) -> bool,
[src]
F: FnMut(&Self::Item) -> bool,
pub fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<T>,
[src]
F: FnMut(Self::Item) -> Option<T>,
pub fn fuse(self) -> Fuse<Self>
[src]
pub fn take(self, n: usize) -> Take<Self>
[src]
pub fn take_while<F>(self, f: F) -> TakeWhile<Self, F> where
F: FnMut(&Self::Item) -> bool,
[src]
F: FnMut(&Self::Item) -> bool,
pub fn skip(self, n: usize) -> Skip<Self>
[src]
pub fn skip_while<F>(self, f: F) -> SkipWhile<Self, F> where
F: FnMut(&Self::Item) -> bool,
[src]
F: FnMut(&Self::Item) -> bool,
pub fn all<F>(&mut self, f: F) -> AllFuture<'_, Self, F> where
Self: Unpin,
F: FnMut(Self::Item) -> bool,
[src]
Self: Unpin,
F: FnMut(Self::Item) -> bool,
pub fn any<F>(&mut self, f: F) -> AnyFuture<'_, Self, F> where
Self: Unpin,
F: FnMut(Self::Item) -> bool,
[src]
Self: Unpin,
F: FnMut(Self::Item) -> bool,
pub fn chain<U>(self, other: U) -> Chain<Self, U> where
U: Stream<Item = Self::Item>,
[src]
U: Stream<Item = Self::Item>,
pub fn fold<B, F>(self, init: B, f: F) -> FoldFuture<Self, B, F> where
F: FnMut(B, Self::Item) -> B,
[src]
F: FnMut(B, Self::Item) -> B,
pub fn collect<T>(self) -> Collect<Self, T> where
T: FromStream<Self::Item>,
[src]
T: FromStream<Self::Item>,
pub fn timeout(self, duration: Duration) -> Timeout<Self>
[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.
pub 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.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<S, T, E> TryStream for S where
S: Stream<Item = Result<T, E>> + ?Sized,
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
pub fn try_poll_next(
self: Pin<&mut S>,
cx: &mut Context<'_>
) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>
self: Pin<&mut S>,
cx: &mut Context<'_>
) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>
impl<S> TryStreamExt for S where
S: TryStream + ?Sized,
S: TryStream + ?Sized,
pub fn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>,
Self::Error: Into<E>,
pub fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnMut(Self::Ok) -> T,
F: FnMut(Self::Ok) -> T,
pub fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnMut(Self::Error) -> E,
F: FnMut(Self::Error) -> E,
pub fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
pub fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
pub fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnMut(&Self::Ok),
F: FnMut(&Self::Ok),
pub fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnMut(&Self::Error),
F: FnMut(&Self::Error),
pub fn into_stream(self) -> IntoStream<Self>
pub fn try_next(&mut self) -> TryNext<'_, Self> where
Self: Unpin,
Self: Unpin,
pub 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>,
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>,
pub 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>,
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
pub 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>,
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
pub 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,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>,
pub fn try_collect<C>(self) -> TryCollect<Self, C> where
C: Default + Extend<Self::Ok>,
C: Default + Extend<Self::Ok>,
pub fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: Future<Output = bool>,
F: FnMut(&Self::Ok) -> Fut,
Fut: Future<Output = bool>,
pub 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>,
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
pub fn try_flatten(self) -> TryFlatten<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
pub 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>,
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>,
pub fn try_concat(self) -> TryConcat<Self> where
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default,
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default,
pub fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
pub fn try_buffered(self, n: usize) -> TryBuffered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
pub fn try_poll_next_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin,
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin,
pub fn into_async_read(self) -> IntoAsyncRead<Self> where
Self: TryStreamExt<Error = Error> + Unpin,
Self::Ok: AsRef<[u8]>,
Self: TryStreamExt<Error = Error> + Unpin,
Self::Ok: AsRef<[u8]>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,