Re-add future::select_all

Author: taiki-e

futures-util/src/future/disabled/select_all.rs

@@ -41,6 +41,14 @@ mod join_all;
 #[cfg(feature = "alloc")]
 pub use self::join_all::{join_all, JoinAll};
 
+mod select;
+pub use self::select::{select, Select};
+
+#[cfg(feature = "alloc")]
+mod select_all;
+#[cfg(feature = "alloc")]
+pub use self::select_all::{select_all, SelectAll};
+
 // Combinators
 mod flatten;
 pub use self::flatten::Flatten;
@@ -57,9 +65,6 @@ pub use self::into_stream::IntoStream;
 mod map;
 pub use self::map::Map;
 
-mod select;
-pub use self::select::{select, Select};
-
 mod then;
 pub use self::then::Then;
 
@@ -98,11 +103,6 @@ mod remote_handle;
 #[cfg(feature = "std")]
 pub use self::remote_handle::{Remote, RemoteHandle};
 
-// #[cfg(feature = "std")]
-// mod select_all;
-// #[cfg(feature = "std")]
-// pub use self::select_all::{SelectAll, SelectAllNext, select_all};
-
 // #[cfg(feature = "std")]
 // mod select_ok;
 // #[cfg(feature = "std")]

futures-util/src/future/mod.rs

@@ -0,0 +1,62 @@
+use core::iter::FromIterator;
+use core::mem;
+use core::pin::Pin;
+use alloc::vec::Vec;
+use futures_core::future::Future;
+use futures_core::task::{Context, Poll};
+
+/// Future for the [`select_all`] function.
+#[derive(Debug)]
+#[must_use = "futures do nothing unless polled"]
+pub struct SelectAll<Fut> {
+    inner: Vec<Fut>,
+}
+
+impl<Fut: Unpin> Unpin for SelectAll<Fut> {}
+
+/// Creates a new future which will select over a list of futures.
+///
+/// The returned future will wait for any future within `iter` to be ready. Upon
+/// completion the item resolved will be returned, along with the index of the
+/// future that was ready and the list of all the remaining futures.
+///
+/// # Panics
+///
+/// This function will panic if the iterator specified contains no items.
+pub fn select_all<I>(iter: I) -> SelectAll<I::Item>
+    where I: IntoIterator,
+          I::Item: Future + Unpin,
+{
+    let ret = SelectAll {
+        inner: iter.into_iter().collect()
+    };
+    assert!(!ret.inner.is_empty());
+    ret
+}
+
+impl<Fut: Future + Unpin> Future for SelectAll<Fut> {
+    type Output = (Fut::Output, usize, Vec<Fut>);
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let item = self.inner.iter_mut().enumerate().find_map(|(i, f)| {
+            match Pin::new(f).poll(cx) {
+                Poll::Pending => None,
+                Poll::Ready(e) => Some((i, e)),
+            }
+        });
+        match item {
+            Some((idx, res)) => {
+                self.inner.remove(idx);
+                let rest = mem::replace(&mut self.inner, Vec::new());
+                Poll::Ready((res, idx, rest))
+            }
+            None => Poll::Pending,
+        }
+    }
+}
+
+impl<Fut: Future + Unpin> FromIterator<Fut> for SelectAll<Fut> {
+    fn from_iter<T: IntoIterator<Item = Fut>>(iter: T) -> Self {
+        select_all(iter)
+    }
+}

futures-util/src/future/select_all.rs

@@ -207,7 +207,10 @@ pub mod future {
     };
 
     #[cfg(feature = "alloc")]
-    pub use futures_util::future::{join_all, JoinAll};
+    pub use futures_util::future::{
+        join_all, JoinAll,
+        select_all, SelectAll,
+    };
 
     #[cfg_attr(
         feature = "cfg-target-has-atomic",
@@ -224,7 +227,7 @@ pub mod future {
         // For FutureExt:
         CatchUnwind, Shared,
 
-        // ToDo: SelectAll, SelectOk, select_all, select_ok
+        // ToDo: SelectOk, select_ok
     };
 
     pub use futures_util::try_future::{

futures/src/lib.rs

@@ -0,0 +1,25 @@
+use futures::executor::block_on;
+use futures::future::{ready, select_all};
+
+#[test]
+fn smoke() {
+    let v = vec![
+        ready(1),
+        ready(2),
+        ready(3),
+    ];
+
+    let (i, idx, v) = block_on(select_all(v));
+    assert_eq!(i, 1);
+    assert_eq!(idx, 0);
+
+    let (i, idx, v) = block_on(select_all(v));
+    assert_eq!(i, 2);
+    assert_eq!(idx, 0);
+
+    let (i, idx, v) = block_on(select_all(v));
+    assert_eq!(i, 3);
+    assert_eq!(idx, 0);
+
+    assert!(v.is_empty());
+}