test

Author: Roman Proskuryakov

Cargo.toml

@@ -12,6 +12,7 @@ edition = "2018"
 
 [dependencies]
 pin-utils = "=0.1.0-alpha.4"
+async-trait = "0.1"
 
 [dependencies.futures]
 version = "=0.3.0-alpha.17"

examples/future.rs

@@ -7,7 +7,7 @@ fn main() {
     executor::block_on(async {
         let future = ready(Ok::<i32, i32>(1));
         let future = and_then(future, |x| ready(Ok::<i32, i32>(x + 3)));
-        let future = inspect(future, |x| { dbg!(x); });
+        let future = future.inspect(|x| { dbg!(x); });
         assert_eq!(future.await, Ok(4));
     });
 }

src/future.rs

@@ -1,28 +1,52 @@
-use futures::future::Future;
+use core::future::Future;
 use futures::stream::Stream;
-
 use core::task::{Poll, Context};
+use async_trait::async_trait;
 
 pub async fn ready<T>(value: T) -> T {
     value
 }
 
-pub async fn map<Fut, U, F>(future: Fut, f: F) -> U
-    where F: FnOnce(Fut::Output) -> U,
-          Fut: Future,
-{
-    f(future.await)
-}
+impl<T: ?Sized> FutureExt for T where T: Future {}
 
-pub async fn then<FutA, FutB, F>(future: FutA, f: F) -> FutB::Output
-    where F: FnOnce(FutA::Output) -> FutB,
-          FutA: Future,
-          FutB: Future,
-{
-    let new_future = f(future.await);
-    new_future.await
+#[async_trait]
+pub trait FutureExt: Future {
+    async fn map<U, F>(self, f: F) -> U
+        where F: FnOnce(Self::Output) -> U + Send,
+              Self: Sized,
+    {
+        f(self.await)
+    }
+
+    async fn then<Fut, F>(self, f: F) -> Fut::Output
+        where F: FnOnce(Self::Output) -> Fut + Send,
+              Fut: Future + Send,
+              Self: Sized,
+    {
+        let new_future = f(self.await);
+        new_future.await
+    }
+
+    async fn flatten(self) -> <<Self as Future>::Output as Future>::Output
+        where <Self as Future>::Output: Future + Send,
+              Self: Sized,
+    {
+        let nested_future = self.await;
+        nested_future.await
+    }
+
+    async fn inspect<F>(self, f: F) -> Self::Output
+        where F: FnOnce(&Self::Output) + Send,
+              Self: Sized,
+    {
+        let future_result = self.await;
+        f(&future_result);
+        future_result
+    }
 }
 
+
+
 pub async fn and_then<FutA, FutB, F, T, U, E>(future: FutA, f: F) -> Result<U, E>
     where F: FnOnce(T) -> FutB,
           FutA: Future<Output = Result<T,E>>,
@@ -65,23 +89,6 @@ pub async fn map_err<Fut, F, T, E, U>(future: Fut, f: F) -> Result<T, U>
     future.await.map_err(f)
 }
 
-pub async fn flatten<FutA, FutB>(future: FutA) -> FutB::Output
-    where FutA: Future<Output = FutB>,
-          FutB: Future,
-{
-    let nested_future = future.await;
-    nested_future.await
-}
-
-pub async fn inspect<Fut, F>(future: Fut, f: F) -> Fut::Output
-    where Fut: Future,
-          F: FnOnce(&Fut::Output),
-{
-    let future_result = future.await;
-    f(&future_result);
-    future_result
-}
-
 pub async fn err_into<Fut, T, E, U>(future: Fut) -> Result<T,U>
     where Fut: Future<Output = Result<T,E>>,
           E: Into<U>,
@@ -165,7 +172,7 @@ mod tests {
     fn test_map() {
         executor::block_on(async {
             let future = ready(1);
-            let new_future = map(future, |x| x + 3);
+            let new_future = future.map(|x| x + 3);
             assert_eq!(new_future.await, 4);
         });
     }
@@ -174,7 +181,7 @@ mod tests {
     fn test_then() {
         executor::block_on(async {
             let future = ready(1);
-            let new_future = then(future, |x| ready(x + 3));
+            let new_future = future.then(|x| ready(x + 3));
             assert_eq!(new_future.await, 4);
         });
     }
@@ -228,7 +235,7 @@ mod tests {
     fn test_flatten() {
         executor::block_on(async {
             let nested_future = ready(ready(1));
-            let future = flatten(nested_future);
+            let future = nested_future.flatten();
             assert_eq!(future.await, 1);
         });
     }
@@ -237,7 +244,7 @@ mod tests {
     fn test_inspect() {
         executor::block_on(async {
             let future = ready(1);
-            let new_future = inspect(future, |&x| assert_eq!(x, 1));
+            let new_future = future.inspect(|&x| assert_eq!(x, 1));
             assert_eq!(new_future.await, 1);
         });
     }