Add Future::delay #341 [WIP]

src/future/delay.rs

@@ -0,0 +1,43 @@
+use crate::future::Future;
+use std::pin::Pin;
+use std::time::Duration;
+
+use crate::task::{Context, Poll};
+
+#[doc(hidden)]
+#[allow(missing_debug_implementations)]
+pub struct Delay<F> {
+    fut: F,
+    delay: futures_timer::Delay,
+    delay_done: bool,
+}
+
+impl<F> Delay<F> {
+    pin_utils::unsafe_pinned!(fut: F);
+    pin_utils::unsafe_pinned!(delay: futures_timer::Delay);
+    pin_utils::unsafe_unpinned!(delay_done: bool);
+
+    pub(super) fn new(fut: F, dur: Duration) -> Self {
+        Delay {
+            fut,
+            delay: futures_timer::Delay::new(dur),
+            delay_done: false,
+        }
+    }
+}
+
+impl<F> Future for Delay<F>
+where
+    F: Future
+{
+    type Output = F::Output;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        if !self.delay_done {
+            futures_core::ready!(self.as_mut().delay().poll(cx));
+            *self.as_mut().delay_done() = true;
+        }
+
+        self.as_mut().fut().poll(cx)
+    }
+}

src/future/future.rs

@@ -1,3 +1,5 @@
+use crate::future::delay::Delay;
+
 extension_trait! {
     use std::pin::Pin;
     use std::ops::{Deref, DerefMut};
@@ -99,6 +101,13 @@ extension_trait! {
     }
 
     pub trait FutureExt: std::future::Future {
+        #[doc = r#"
+        "#]
+        fn delay(self, dur: std::time::Duration) -> Delay<Self>
+            where Self: Sized
+        {
+            Delay::new(self, dur)
+        }
     }
 
     impl<F: Future + Unpin + ?Sized> Future for Box<F> {

src/future/mod.rs

@@ -55,6 +55,7 @@ mod pending;
 mod poll_fn;
 mod ready;
 mod timeout;
+mod delay;
 
 cfg_unstable! {
     #[doc(inline)]

src/prelude.rs

@@ -38,6 +38,8 @@ pub use crate::io::seek::SeekExt as _;
 pub use crate::io::write::WriteExt as _;
 #[doc(hidden)]
 pub use crate::stream::stream::StreamExt as _;
+#[doc(hidden)]
+pub use crate::future::future::FutureExt as _;
 
 cfg_unstable! {
     #[doc(no_inline)]

tests/delay.rs

@@ -0,0 +1,19 @@
+use async_std::future;
+use async_std::task;
+use async_std::prelude::*;
+
+use std::time::Duration;
+use std::time::Instant;
+
+#[test]
+fn delay() {
+    task::block_on( async {
+        let start = Instant::now();
+        let a = future::ready("a");
+        let b = future::ready("b");
+        let c = future::ready("c").delay(Duration::from_secs(1));
+        dbg!(future::join!(a, b, c).await);
+        let elapsed = start.elapsed().as_secs();
+        assert_eq!(elapsed, 1);
+    })
+}