Merge branch 'master' into compat

Author: MajorBreakfast

futures-util/src/async_await/join.rs

@@ -1,23 +1,23 @@
 //! The `join` macro.
 
 /// Polls multiple futures simultaneously, returning a tuple
-/// of all results once complete. 
-/// 
+/// of all results once complete.
+///
 /// While `join!(a, b)` is similar to `(await!(a), await!(b))`,
 /// `join!` polls both futures concurrently and therefore is more efficent.
-/// 
+///
 /// This macro is only usable inside of async functions, closures, and blocks.
-/// 
+///
 /// # Examples
-/// 
+///
 /// ```
 /// #![feature(pin, async_await, await_macro, futures_api)]
 /// # futures::executor::block_on(async {
 /// use futures::{join, future};
 ///
 /// let a = future::ready(1);
 /// let b = future::ready(2);
-/// 
+///
 /// assert_eq!(join!(a, b), (1, 2));
 /// # });
 /// ```
@@ -31,7 +31,7 @@ macro_rules! join {
         loop {
             let mut all_done = true;
             $(
-                if let $crate::core_reexport::task::Poll::Pending = $crate::poll!($fut.reborrow()) {
+                if $crate::poll!($fut.reborrow()).is_pending() {
                     all_done = false;
                 }
             )*
@@ -47,3 +47,77 @@ macro_rules! join {
         )*)
     } }
 }
+
+/// Polls multiple futures simultaneously, resolving to a [`Result`] containing
+/// either a tuple of the successful outputs or an error.
+///
+/// `try_join!` is similar to [`join!`], but completes immediately if any of
+/// the futures return an error.
+///
+/// This macro is only usable inside of async functions, closures, and blocks.
+///
+/// # Examples
+///
+/// When used on multiple futures that return `Ok`, `try_join!` will return
+/// `Ok` of a tuple of the values:
+///
+/// ```
+/// #![feature(pin, async_await, await_macro, futures_api)]
+/// # futures::executor::block_on(async {
+/// use futures::{try_join, future};
+///
+/// let a = future::ready(Ok::<i32, i32>(1));
+/// let b = future::ready(Ok::<u64, i32>(2));
+///
+/// assert_eq!(try_join!(a, b), Ok((1, 2)));
+/// # });
+/// ```
+///
+/// If one of the futures resolves to an error, `try_join!` will return
+/// that error:
+///
+/// ```
+/// #![feature(pin, async_await, await_macro, futures_api)]
+/// # futures::executor::block_on(async {
+/// use futures::{try_join, future};
+///
+/// let a = future::ready(Ok::<i32, i32>(1));
+/// let b = future::ready(Err::<u64, i32>(2));
+///
+/// assert_eq!(try_join!(a, b), Err(2));
+/// # });
+/// ```
+#[macro_export]
+macro_rules! try_join {
+    ($($fut:ident),*) => { {
+        $(
+            let mut $fut = $crate::future::maybe_done($fut);
+            $crate::pin_mut!($fut);
+        )*
+        let res: $crate::core_reexport::result::Result<(), _> = loop {
+            let mut all_done = true;
+            $(
+                if $crate::poll!($fut.reborrow()).is_pending() {
+                    all_done = false;
+                } else if $fut.reborrow().output_mut().unwrap().is_err() {
+                    // `.err().unwrap()` rather than `.unwrap_err()` so that we don't introduce
+                    // a `T: Debug` bound.
+                    break $crate::core_reexport::result::Result::Err(
+                        $fut.reborrow().take_output().unwrap().err().unwrap()
+                    );
+                }
+            )*
+            if all_done {
+                break $crate::core_reexport::result::Result::Ok(());
+            } else {
+                $crate::pending!();
+            }
+        };
+
+        res.map(|()| ($(
+            // `.ok().unwrap()` rather than `.unwrap()` so that we don't introduce
+            // an `E: Debug` bound.
+            $fut.reborrow().take_output().unwrap().ok().unwrap(),
+        )*))
+    } }
+}

futures-util/src/future/join.rs

@@ -37,9 +37,6 @@ macro_rules! generate {
                     $($Fut: maybe_done($Fut)),*
                 }
             }
-        }
-
-        impl<$($Fut: Future),*> $Join<$($Fut),*> {
             $(
                 unsafe_pinned!($Fut: MaybeDone<$Fut>);
             )*

futures-util/src/future/maybe_done.rs

@@ -44,8 +44,25 @@ pub fn maybe_done<Fut: Future>(future: Fut) -> MaybeDone<Fut> {
 }
 
 impl<Fut: Future> MaybeDone<Fut> {
+    /// Returns an [`Option`] containing a mutable 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]
+    #[allow(needless_lifetimes)] // https://github.com/rust-lang/rust/issues/52675
+    pub fn output_mut<'a>(self: PinMut<'a, Self>) -> Option<&'a mut Fut::Output> {
+        unsafe {
+            let this = PinMut::get_mut_unchecked(self);
+            match this {
+                MaybeDone::Done(res) => Some(res),
+                _ => None,
+            }
+        }
+    }
+
     /// Attempt to take the output of a `MaybeDone` without driving it
     /// towards completion.
+    #[inline]
     pub fn take_output(self: PinMut<Self>) -> Option<Fut::Output> {
         unsafe {
             let this = PinMut::get_mut_unchecked(self);

futures-util/src/lib.rs

@@ -23,7 +23,7 @@ macro_rules! if_std {
 
 #[doc(hidden)]
 pub mod core_reexport {
-    pub use core::{mem, marker, future, task};
+    pub use core::*;
 }
 
 macro_rules! delegate_sink {

futures-util/src/macros/pin.rs

@@ -31,9 +31,9 @@
 #[macro_export]
 macro_rules! unsafe_pinned {
     ($f:tt: $t:ty) => (
-        fn $f<'a>(
-            self: &'a mut $crate::core_reexport::mem::PinMut<Self>
-        ) -> $crate::core_reexport::mem::PinMut<'a, $t> {
+        fn $f<'__a>(
+            self: &'__a mut $crate::core_reexport::mem::PinMut<Self>
+        ) -> $crate::core_reexport::mem::PinMut<'__a, $t> {
             unsafe {
                 $crate::core_reexport::mem::PinMut::map_unchecked(
                     self.reborrow(), |x| &mut x.$f
@@ -70,9 +70,9 @@ macro_rules! unsafe_pinned {
 #[macro_export]
 macro_rules! unsafe_unpinned {
     ($f:tt: $t:ty) => (
-        fn $f<'a>(
-            self: &'a mut $crate::core_reexport::mem::PinMut<Self>
-        ) -> &'a mut $t {
+        fn $f<'__a>(
+            self: &'__a mut $crate::core_reexport::mem::PinMut<Self>
+        ) -> &'__a mut $t {
             unsafe {
                 &mut $crate::core_reexport::mem::PinMut::get_mut_unchecked(
                     self.reborrow()

futures-util/src/stream/buffer_unordered.rs

@@ -126,9 +126,9 @@ where
 
         // If more values are still coming from the stream, we're not done yet
         if self.stream.is_done() {
-            Poll::Pending
-        } else {
             Poll::Ready(None)
+        } else {
+            Poll::Pending
         }
     }
 }

futures-util/src/stream/buffered.rs

@@ -122,9 +122,9 @@ where
 
         // If more values are still coming from the stream, we're not done yet
         if self.stream.is_done() {
-            Poll::Pending
-        } else {
             Poll::Ready(None)
+        } else {
+            Poll::Pending
         }
     }
 }

futures-util/src/stream/mod.rs

@@ -740,6 +740,30 @@ pub trait StreamExt: Stream {
     ///
     /// This method is only available when the `std` feature of this
     /// library is activated, and it is activated by default.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(async_await, await_macro)]
+    /// # futures::executor::block_on(async {
+    /// use futures::channel::oneshot;
+    /// use futures::stream::{self, StreamExt};
+    ///
+    /// let (send_one, recv_one) = oneshot::channel();
+    /// let (send_two, recv_two) = oneshot::channel();
+    ///
+    /// let stream_of_futures = stream::iter(vec![recv_one, recv_two]);
+    /// let mut buffered = stream_of_futures.buffer_unordered(10);
+    ///
+    /// send_two.send(2i32);
+    /// assert_eq!(await!(buffered.next()), Some(Ok(2i32)));
+    ///
+    /// send_one.send(1i32);
+    /// assert_eq!(await!(buffered.next()), Some(Ok(1i32)));
+    ///
+    /// assert_eq!(await!(buffered.next()), None);
+    /// # })
+    /// ```
     #[cfg(feature = "std")]
     fn buffer_unordered(self, n: usize) -> BufferUnordered<Self>
         where Self::Item: Future,