Re-add try_future::select_ok (#1557)

Author: taiki-e

futures-util/src/future/mod.rs

@@ -105,11 +105,6 @@ mod remote_handle;
 #[cfg(feature = "std")]
 pub use self::remote_handle::{Remote, RemoteHandle};
 
-// #[cfg(feature = "std")]
-// mod select_ok;
-// #[cfg(feature = "std")]
-// pub use self::select_ok::{SelectOk, select_ok};
-
 #[cfg(feature = "std")]
 mod shared;
 #[cfg(feature = "std")]

futures-util/src/try_future/mod.rs

@@ -8,20 +8,6 @@ use futures_sink::Sink;
 
 #[cfg(feature = "compat")] use crate::compat::Compat;
 
-/* TODO
-mod select;
-pub use self::select::Select;
-
-#[cfg(feature = "std")]
-mod select_all;
-#[cfg(feature = "std")]
-mod select_ok;
-#[cfg(feature = "std")]
-pub use self::select_all::{SelectAll, SelectAllNext, select_all};
-#[cfg(feature = "std")]
-pub use self::select_ok::{SelectOk, select_ok};
-*/
-
 mod try_join;
 pub use self::try_join::{
     try_join, try_join3, try_join4, try_join5,
@@ -33,6 +19,15 @@ mod try_join_all;
 #[cfg(feature = "alloc")]
 pub use self::try_join_all::{try_join_all, TryJoinAll};
 
+// TODO
+// mod try_select;
+// pub use self::try_select::{try_select, TrySelect};
+
+#[cfg(feature = "alloc")]
+mod select_ok;
+#[cfg(feature = "alloc")]
+pub use self::select_ok::{select_ok, SelectOk};
+
 // Combinators
 mod and_then;
 pub use self::and_then::AndThen;

futures-util/src/future/disabled/select_ok.rs renamed to futures-util/src/try_future/select_ok.rs

@@ -1,19 +1,19 @@
-//! Definition of the `SelectOk` combinator, finding the first successful future
-//! in a list.
-
-use std::mem;
-use std::prelude::v1::*;
-
-use futures_core::{Future, IntoFuture, Poll, Async};
-use futures_core::task;
+use core::iter::FromIterator;
+use core::mem;
+use core::pin::Pin;
+use alloc::vec::Vec;
+use futures_core::future::{Future, TryFuture};
+use futures_core::task::{Context, Poll};
 
 /// Future for the [`select_ok`] function.
 #[derive(Debug)]
 #[must_use = "futures do nothing unless polled"]
-pub struct SelectOk<A> where A: Future {
-    inner: Vec<A>,
+pub struct SelectOk<Fut> {
+    inner: Vec<Fut>,
 }
 
+impl<Fut: Unpin> Unpin for SelectOk<Fut> {}
+
 /// Creates a new future which will select the first successful future over a list of futures.
 ///
 /// The returned future will wait for any future within `iter` to be ready and Ok. Unlike
@@ -24,55 +24,56 @@ pub struct SelectOk<A> where A: Future {
 /// # Panics
 ///
 /// This function will panic if the iterator specified contains no items.
-pub fn select_ok<I>(iter: I) -> SelectOk<<I::Item as IntoFuture>::Future>
+pub fn select_ok<I>(iter: I) -> SelectOk<I::Item>
     where I: IntoIterator,
-          I::Item: IntoFuture,
+          I::Item: TryFuture + Unpin,
 {
     let ret = SelectOk {
-        inner: iter.into_iter()
-                   .map(|a| a.into_future())
-                   .collect(),
+        inner: iter.into_iter().collect()
     };
-    assert!(ret.inner.len() > 0);
+    assert!(!ret.inner.is_empty());
     ret
 }
 
-impl<A> Future for SelectOk<A> where A: Future {
-    type Item = (A::Item, Vec<A>);
-    type Error = A::Error;
+impl<Fut: TryFuture + Unpin> Future for SelectOk<Fut> {
+    type Output = Result<(Fut::Ok, Vec<Fut>), Fut::Error>;
 
-    fn poll(&mut self, cx: &mut Context<'_>) -> Poll<Self::Item, Self::Error> {
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         // loop until we've either exhausted all errors, a success was hit, or nothing is ready
         loop {
-            let item = self.inner.iter_mut().enumerate().filter_map(|(i, f)| {
-                match f.poll(cx) {
-                    Ok(Poll::Pending) => None,
-                    Ok(Poll::Ready(e)) => Some((i, Ok(e))),
-                    Err(e) => Some((i, Err(e))),
+            let item = self.inner.iter_mut().enumerate().find_map(|(i, f)| {
+                match Pin::new(f).try_poll(cx) {
+                    Poll::Pending => None,
+                    Poll::Ready(e) => Some((i, e)),
                 }
-            }).next();
-
+            });
             match item {
                 Some((idx, res)) => {
                     // always remove Ok or Err, if it's not the last Err continue looping
                     drop(self.inner.remove(idx));
                     match res {
                         Ok(e) => {
                             let rest = mem::replace(&mut self.inner, Vec::new());
-                            return Ok(Poll::Ready((e, rest)))
-                        },
+                            return Poll::Ready(Ok((e, rest)))
+                        }
                         Err(e) => {
                             if self.inner.is_empty() {
-                                return Err(e)
+                                return Poll::Ready(Err(e))
                             }
-                        },
+                        }
                     }
                 }
                 None => {
                     // based on the filter above, nothing is ready, return
-                    return Ok(Poll::Pending)
-                },
+                    return Poll::Pending
+                }
             }
         }
     }
 }
+
+impl<Fut: TryFuture + Unpin> FromIterator<Fut> for SelectOk<Fut> {
+    fn from_iter<T: IntoIterator<Item = Fut>>(iter: T) -> Self {
+        select_ok(iter)
+    }
+}

futures/src/lib.rs

@@ -235,8 +235,6 @@ pub mod future {
         Remote, RemoteHandle,
         // For FutureExt:
         CatchUnwind, Shared,
-
-        // ToDo: SelectOk, select_ok
     };
 
     pub use futures_util::try_future::{
@@ -254,6 +252,7 @@ pub mod future {
     #[cfg(feature = "alloc")]
     pub use futures_util::try_future::{
         try_join_all, TryJoinAll,
+        select_ok, SelectOk,
     };
 }
 

futures/tests_disabled/select_ok.rs renamed to futures/tests/select_ok.rs

@@ -1,4 +1,5 @@
 use futures::executor::block_on;
+use futures::future::{err, ok, select_ok};
 
 #[test]
 fn ignore_err() {