diff --git a/src/future/into_future.rs b/src/future/into_future.rs
new file mode 100644
index 000000000..58b676615
--- /dev/null
+++ b/src/future/into_future.rs
@@ -0,0 +1,54 @@
+use crate::future::Future;
+
+/// Convert a type into a `Future`.
+///
+/// # Examples
+///
+/// ```
+/// use async_std::future::{Future, IntoFuture};
+/// use async_std::io;
+/// use async_std::pin::Pin;
+///
+/// struct Client;
+///
+/// impl Client {
+///     pub async fn send(self) -> io::Result<()> {
+///         // Send a request
+///         Ok(())
+///     }
+/// }
+///
+/// impl IntoFuture for Client {
+///     type Output = io::Result<()>;
+///
+///     type Future = Pin<Box<dyn Future<Output = Self::Output>>>;
+///
+///     fn into_future(self) -> Self::Future {
+///         Box::pin(async {
+///             self.send().await
+///         })
+///     }
+/// }
+/// ```
+#[cfg(any(feature = "unstable", feature = "docs"))]
+#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
+pub trait IntoFuture {
+    /// The type of value produced on completion.
+    type Output;
+
+    /// Which kind of future are we turning this into?
+    type Future: Future<Output = Self::Output>;
+
+    /// Create a future from a value
+    fn into_future(self) -> Self::Future;
+}
+
+impl<T: Future> IntoFuture for T {
+    type Output = T::Output;
+
+    type Future = T;
+
+    fn into_future(self) -> Self::Future {
+        self
+    }
+}
diff --git a/src/future/mod.rs b/src/future/mod.rs
index 1f67e1aa5..b1a68b991 100644
--- a/src/future/mod.rs
+++ b/src/future/mod.rs
@@ -60,7 +60,10 @@ mod ready;
 
 cfg_if! {
     if #[cfg(any(feature = "unstable", feature = "docs"))] {
+        mod into_future;
         mod timeout;
+
+        pub use into_future::IntoFuture;
         pub use timeout::{timeout, TimeoutError};
     }
 }