Renamed all types that return a Future to have the suffix of 'Future' (#41)

* Renamed all types that return a Future to have the suffix of 'Future' in
preparation for filesystem support where that is the only logical pattern.
For example Connect (the struct returned from TcpStream::connect(..)) returns
a ConnectFuture instead of the original Connect. Closes: #40

* Set JoinHandleFuture type back to the original JoinHandle for consistency.

Author: bryandmc

src/net/tcp.rs

@@ -92,8 +92,8 @@ impl TcpStream {
     /// let stream = TcpStream::connect("127.0.0.1:0").await?;
     /// # Ok(())}
     /// ```
-    pub fn connect<A: ToSocketAddrs>(addr: A) -> Connect {
-        Connect {
+    pub fn connect<A: ToSocketAddrs>(addr: A) -> ConnectFuture {
+        ConnectFuture {
             addrs: Some(addr.to_socket_addrs().map(|iter| iter.collect())),
             last_err: None,
             future: None,
@@ -218,14 +218,14 @@ impl AsyncWrite for TcpStream {
 /// [`TcpStream::connect`]: struct.TcpStream.html#method.connect
 /// [`TcpStream`]: struct.TcpStream.html
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct Connect {
+pub struct ConnectFuture {
     addrs: Option<io::Result<VecDeque<SocketAddr>>>,
     last_err: Option<io::Error>,
     future: Option<BoxFuture<'static, io::Result<Pin<Box<dyn runtime_raw::TcpStream>>>>>,
     runtime: &'static dyn runtime_raw::Runtime,
 }
 
-impl Future for Connect {
+impl Future for ConnectFuture {
     type Output = io::Result<TcpStream>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
@@ -267,7 +267,7 @@ impl Future for Connect {
     }
 }
 
-impl fmt::Debug for Connect {
+impl fmt::Debug for ConnectFuture {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Connect")
             .field("addrs", &self.addrs)
@@ -413,8 +413,8 @@ impl TcpListener {
     /// }
     /// # Ok(())}
     /// ```
-    pub fn incoming(&mut self) -> Incoming<'_> {
-        Incoming { inner: self }
+    pub fn incoming(&mut self) -> IncomingStream<'_> {
+        IncomingStream { inner: self }
     }
 
     /// Handle an incoming connection.
@@ -441,9 +441,9 @@ impl TcpListener {
     /// println!("Connected to {}", addr);
     /// # Ok(())}
     /// ```
-    pub fn accept(&mut self) -> Accept<'_> {
+    pub fn accept(&mut self) -> AcceptFuture<'_> {
         let incoming = self.incoming();
-        Accept { inner: incoming }
+        AcceptFuture { inner: incoming }
     }
 }
 
@@ -455,11 +455,11 @@ impl TcpListener {
 /// [`TcpStream`]: struct.TcpStream.html
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 #[derive(Debug)]
-pub struct Accept<'stream> {
-    inner: Incoming<'stream>,
+pub struct AcceptFuture<'stream> {
+    inner: IncomingStream<'stream>,
 }
 
-impl<'stream> Future for Accept<'stream> {
+impl<'stream> Future for AcceptFuture<'stream> {
     type Output = io::Result<(TcpStream, SocketAddr)>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
@@ -479,11 +479,11 @@ impl<'stream> Future for Accept<'stream> {
 /// [`TcpListener`]: struct.TcpStream.html
 #[must_use = "streams do nothing unless polled"]
 #[derive(Debug)]
-pub struct Incoming<'listener> {
+pub struct IncomingStream<'listener> {
     inner: &'listener mut TcpListener,
 }
 
-impl<'listener> Stream for Incoming<'listener> {
+impl<'listener> Stream for IncomingStream<'listener> {
     type Item = io::Result<TcpStream>;
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {

src/net/udp.rs

@@ -144,12 +144,12 @@ impl UdpSocket {
         &'socket mut self,
         buf: &'buf [u8],
         addr: A,
-    ) -> SendTo<'socket, 'buf> {
+    ) -> SendToFuture<'socket, 'buf> {
         let addr = addr
             .to_socket_addrs()
             .map(|mut iter| iter.next())
             .transpose();
-        SendTo {
+        SendToFuture {
             buf,
             addr,
             socket: self,
@@ -179,8 +179,8 @@ impl UdpSocket {
     pub fn recv_from<'socket, 'buf>(
         &'socket mut self,
         buf: &'buf mut [u8],
-    ) -> RecvFrom<'socket, 'buf> {
-        RecvFrom { buf, socket: self }
+    ) -> RecvFromFuture<'socket, 'buf> {
+        RecvFromFuture { buf, socket: self }
     }
 
     /// Gets the value of the `SO_BROADCAST` option for this socket.
@@ -360,7 +360,7 @@ impl UdpSocket {
 /// [`UdpSocket::send_to`]: struct.UdpSocket.html#method.send_to
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 #[derive(Debug)]
-pub struct SendTo<'socket, 'buf> {
+pub struct SendToFuture<'socket, 'buf> {
     /// The open socket we use to send the message from.
     socket: &'socket mut UdpSocket,
     /// The message we're trying to send.
@@ -369,11 +369,11 @@ pub struct SendTo<'socket, 'buf> {
     addr: Option<io::Result<SocketAddr>>,
 }
 
-impl<'socket, 'buf> Future for SendTo<'socket, 'buf> {
+impl<'socket, 'buf> Future for SendToFuture<'socket, 'buf> {
     type Output = io::Result<usize>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let SendTo { socket, buf, addr } = &mut *self;
+        let SendToFuture { socket, buf, addr } = &mut *self;
         let addr = match addr.take() {
             Some(addr) => addr?,
             None => {
@@ -395,16 +395,16 @@ impl<'socket, 'buf> Future for SendTo<'socket, 'buf> {
 /// [`UdpSocket::recv_from`]: struct.UdpSocket.html#method.recv_from
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 #[derive(Debug)]
-pub struct RecvFrom<'socket, 'buf> {
+pub struct RecvFromFuture<'socket, 'buf> {
     socket: &'socket mut UdpSocket,
     buf: &'buf mut [u8],
 }
 
-impl<'socket, 'buf> Future for RecvFrom<'socket, 'buf> {
+impl<'socket, 'buf> Future for RecvFromFuture<'socket, 'buf> {
     type Output = io::Result<(usize, SocketAddr)>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let RecvFrom { socket, buf } = &mut *self;
+        let RecvFromFuture { socket, buf } = &mut *self;
         socket.inner.as_mut().poll_recv_from(cx, buf)
     }
 }