Add future::delay

src/future/future.rs

@@ -9,6 +9,15 @@ cfg_if::cfg_if! {
     }
 }
 
+cfg_if::cfg_if! {
+    if #[cfg(any(feature = "unstable", feature = "docs"))] {
+        mod delay;
+
+        use std::time::Duration;
+        use delay::DelayFuture;
+    }
+}
+
 extension_trait! {
     #[doc = r#"
         A future represents an asynchronous computation.
@@ -105,6 +114,28 @@ extension_trait! {
     }
 
     pub trait FutureExt: std::future::Future {
+        /// Creates a future that is delayed before it starts yielding items.
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// # async_std::task::block_on(async {
+        /// use async_std::future;
+        /// use std::time::Duration;
+        /// use async_std::future::FutureExt;
+        ///
+        /// let a = future::ready(1).delay(Duration::from_millis(2000));
+        /// dbg!(a.await);
+        /// # })
+        /// ```
+        #[cfg_attr(feature = "docs", doc(cfg(unstable)))]
+        #[cfg(any(feature = "unstable", feature = "docs"))]
+        fn delay(self, dur: Duration) -> DelayFuture<Self>
+        where
+            Self: Future + Sized
+        {
+            DelayFuture::new(self, dur)
+        }
     }
 
     impl<F: Future + Unpin + ?Sized> Future for Box<F> {

src/future/future/delay.rs

@@ -0,0 +1,39 @@
+use std::pin::Pin;
+use std::time::Duration;
+
+use futures_timer::Delay;
+
+use crate::future::Future;
+use crate::task::{Context, Poll};
+
+#[doc(hidden)]
+#[derive(Debug)]
+pub struct DelayFuture<F> {
+    future: F,
+    delay: Delay,
+}
+
+impl<F> DelayFuture<F> {
+    pin_utils::unsafe_pinned!(future: F);
+    pin_utils::unsafe_pinned!(delay: Delay);
+
+    pub fn new(future: F, dur: Duration) -> DelayFuture<F> {
+        let delay = Delay::new(dur);
+
+        DelayFuture { future, delay }
+    }
+}
+
+impl<F: Future> Future for DelayFuture<F> {
+    type Output = F::Output;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        match self.as_mut().delay().poll(cx) {
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(_) => match self.future().poll(cx) {
+                Poll::Ready(v) => Poll::Ready(v),
+                Poll::Pending => Poll::Pending,
+            },
+        }
+    }
+}

src/future/mod.rs

@@ -51,6 +51,7 @@ pub use async_macros::{select, try_select};
 use cfg_if::cfg_if;
 
 pub use future::Future;
+pub use future::FutureExt;
 pub use pending::pending;
 pub use poll_fn::poll_fn;
 pub use ready::ready;