try_select

Signed-off-by: Yoshua Wuyts <yoshuawuyts@gmail.com>

Author: yoshuawuyts

src/join.rs

@@ -6,8 +6,6 @@
 /// `join!` polls both futures concurrently and therefore is more efficent.
 ///
 /// This macro is only usable inside of async functions, closures, and blocks.
-/// It is also gated behind the `async-await` feature of this library, which is
-/// _not_ activated by default.
 ///
 /// # Examples
 ///

src/lib.rs

@@ -26,6 +26,7 @@ mod poll_fn;
 mod ready;
 mod select;
 mod try_join;
+mod try_select;
 
 pub use maybe_done::{maybe_done, MaybeDone};
 

src/maybe_done.rs

@@ -43,6 +43,19 @@ impl<Fut: Future> MaybeDone<Fut> {
         }
     }
 
+    /// Returns an [`Option`] containing a reference to the output of the future.
+    /// The output of this method will be [`Some`] if and only if the inner
+    /// future has been completed and [`take_output`](MaybeDone::take_output)
+    /// has not yet been called.
+    #[inline]
+    pub fn output(self: Pin<&Self>) -> Option<&Fut::Output> {
+        let this = self.get_ref();
+        match this {
+            MaybeDone::Done(res) => Some(res),
+            _ => None,
+        }
+    }
+
     /// Attempt to take the output of a `MaybeDone` without driving it
     /// towards completion.
     #[inline]

src/select.rs

@@ -1,13 +1,16 @@
 #![allow(non_snake_case)]
 
+/// Waits for either one of several similarly-typed futures to complete.
 /// Awaits multiple futures simultaneously, returning all results once complete.
 ///
-/// While `join!(a, b)` is similar to `(a.await, b.await)`,
-/// `join!` polls both futures concurrently and therefore is more efficent.
+/// This function will return a new future which awaits for either one of both
+/// futures to complete. If multiple futures are completed at the same time,
+/// resolution will occur in the order that they have been passed.
+///
+/// Note that this macro consumes all futures passed, and once a future is
+/// completed, all other futures are dropped.
 ///
 /// This macro is only usable inside of async functions, closures, and blocks.
-/// It is also gated behind the `async-await` feature of this library, which is
-/// _not_ activated by default.
 ///
 /// # Examples
 ///
@@ -19,6 +22,7 @@
 ///
 /// let a = future::pending();
 /// let b = future::ready(1u8);
+/// let c = future::ready(2u8);
 ///
 /// assert_eq!(select!(a, b).await, 1u8);
 /// # });

src/try_join.rs

@@ -5,8 +5,6 @@
 /// the futures return an error.
 ///
 /// This macro is only usable inside of async functions, closures, and blocks.
-/// It is also gated behind the `async-await` feature of this library, which is
-/// _not_ activated by default.
 ///
 /// # Examples
 ///

src/try_select.rs

@@ -0,0 +1,67 @@
+#![allow(non_snake_case)]
+
+/// Waits for either one of several similarly-typed futures to complete.
+/// Awaits multiple futures simultaneously, returning all results once complete.
+///
+/// `try_select!` is similar to [`select!`], but keeps going if a future
+/// resolved to an error until all futures have been resolved. In which case
+/// the last error found will be returned.
+///
+/// This macro is only usable inside of async functions, closures, and blocks.
+///
+/// # Examples
+///
+/// ```
+/// # futures::executor::block_on(async {
+/// # async fn main() -> Result<(), std::io::Error> {
+/// use async_macros::try_select;
+/// use futures::future;
+/// use std::io::{Error, ErrorKind};
+///
+/// let a = future::pending::<Result<u8, Error>>();
+/// let b = future::ready(Err(Error::from(ErrorKind::Other)));
+/// let c = future::ready(Ok(1u8));
+///
+/// assert_eq!(try_select!(a, b, c).await?, 1u8);
+/// # Ok(())
+/// # }
+/// # main().await.unwrap();
+/// # });
+/// ```
+#[macro_export]
+macro_rules! try_select {
+    ($($fut:ident),* $(,)?) => { {
+        async {
+            $(
+                // Move future into a local so that it is pinned in one place and
+                // is no longer accessible by the end user.
+                let mut $fut = $crate::maybe_done($fut);
+            )*
+            $crate::utils::poll_fn(move |cx| {
+                use $crate::utils::future::Future;
+                use $crate::utils::task::Poll;
+                use $crate::utils::pin::Pin;
+
+                let mut all_done = true;
+
+                $(
+                    let fut = unsafe { Pin::new_unchecked(&mut $fut) };
+                    if Future::poll(fut, cx).is_ready() {
+                        let fut = Pin::new(&$fut);
+                        if fut.output().unwrap().is_ok() {
+                            let fut = unsafe { Pin::new_unchecked(&mut $fut) };
+                            let output = fut.take_output().unwrap();
+                            return Poll::Ready(output);
+                        }
+                    }
+                )*
+
+                if all_done {
+                    unimplemented!();
+                } else {
+                    Poll::Pending
+                }
+            }).await
+        }
+    } }
+}