implement Future::select

Signed-off-by: Yoshua Wuyts <[email protected]>

Author: yoshuawuyts

src/future/future.rs renamed to src/future/future/mod.rs

@@ -1,3 +1,7 @@
+mod select;
+
+use select::Select;
+
 extension_trait! {
     use std::pin::Pin;
     use std::ops::{Deref, DerefMut};
@@ -99,7 +103,6 @@ extension_trait! {
     }
 
     pub trait FutureExt: std::future::Future {
-
         #[doc = r#"
             Waits for either one of several similarly-typed futures to complete.
 
@@ -117,9 +120,9 @@ extension_trait! {
             # Examples
 
             ```
-            #![feature(async_await)]
             # futures::executor::block_on(async {
-            use futures::future;
+            use async_std::prelude::*;
+            use async_std::future;
 
             let a = future::pending();
             let b = future::ready(1u8);
@@ -130,8 +133,12 @@ extension_trait! {
             # });
             ```
         "#]
-        fn select(&mut self) -> () {
-            ()
+        fn select<F>(self, other: F) -> Select<Self, F>
+            where
+                Self: Sized,
+                F: Future<Output = Self::Output>,
+        {
+            Select::new(self, other)
         }
     }
 

src/future/future/select.rs

@@ -0,0 +1,54 @@
+use std::pin::Pin;
+
+use pin_project_lite::pin_project;
+use async_macros::MaybeDone;
+
+use crate::future::Future;
+// use crate::future::MaybeDone;
+use crate::task::{Context, Poll};
+
+pin_project! {
+    #[allow(missing_docs)]
+    #[allow(missing_debug_implementations)]
+    pub struct Select<L, R> where L: Future, R: Future<Output = L::Output> {
+        #[pin] left: MaybeDone<L>,
+        #[pin] right: MaybeDone<R>,
+    }
+}
+
+impl<L, R> Select<L, R>
+where
+    L: Future,
+    R: Future<Output = L::Output>,
+{
+    pub(crate) fn new(left: L, right: R) -> Self {
+        Self {
+            left: MaybeDone::new(left),
+            right: MaybeDone::new(right),
+        }
+    }
+}
+
+impl<L, R> Future for Select<L, R>
+where
+    L: Future,
+    R: Future<Output = L::Output>,
+{
+    type Output = L::Output;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+
+        let mut left = this.left;
+        if Future::poll(Pin::new(&mut left), cx).is_ready() {
+            return Poll::Ready(left.take().unwrap());
+        }
+
+        let mut right = this.right;
+        if Future::poll(Pin::new(&mut right), cx).is_ready() {
+            return Poll::Ready(right.take().unwrap());
+        }
+
+        Poll::Pending
+    }
+}