Merge pull request #4 from kpp/dot_await

Switch to .await syntax

Author: kpp

.travis.yml

@@ -1,7 +1,7 @@
 language: rust
 sudo: false
 rust:
-  - nightly-2019-04-26
+  - nightly-2019-06-27
 
 os:
  - linux

Cargo.toml

@@ -14,5 +14,5 @@ edition = "2018"
 pin-utils = "=0.1.0-alpha.4"
 
 [dependencies.futures]
-version = "=0.3.0-alpha.15"
+version = "=0.3.0-alpha.16"
 package = "futures-preview"

README.md

@@ -9,7 +9,7 @@ like `FutureExt::map`, `TryFutureExt::and_then`...
 
 # Requirements
 
-Rust nightly-2019-04-26 for async_await, await_macro...
+Rust nightly-2019-06-27 for async_await, await_macro...
 
 # State
 

examples/future.rs

@@ -8,6 +8,6 @@ fn main() {
         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); });
-        assert_eq!(await!(future), Ok(4));
+        assert_eq!(future.await, Ok(4));
     });
 }

src/future.rs

@@ -11,30 +11,27 @@ pub async fn map<Fut, U, F>(future: Fut, f: F) -> U
     where F: FnOnce(Fut::Output) -> U,
           Fut: Future,
 {
-    let future_result = await!(future);
-    f(future_result)
+    f(future.await)
 }
 
 pub async fn then<FutA, FutB, F>(future: FutA, f: F) -> FutB::Output
     where F: FnOnce(FutA::Output) -> FutB,
           FutA: Future,
           FutB: Future,
 {
-    let future_result = await!(future);
-    let new_future = f(future_result);
-    await!(new_future)
+    let new_future = f(future.await);
+    new_future.await
 }
 
 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>>,
           FutB: Future<Output = Result<U,E>>,
 {
-    let future_result = await!(future);
-    match future_result {
+    match future.await {
         Ok(ok) => {
             let new_future = f(ok);
-            await!(new_future)
+            new_future.await
         },
         Err(err) => Err(err),
     }
@@ -45,12 +42,11 @@ pub async fn or_else<FutA, FutB, F, T, E, U>(future: FutA, f: F) -> Result<T, U>
           FutA: Future<Output = Result<T,E>>,
           FutB: Future<Output = Result<T,U>>,
 {
-    let future_result = await!(future);
-    match future_result {
+    match future.await {
         Ok(ok) => Ok(ok),
         Err(err) => {
             let new_future = f(err);
-            await!(new_future)
+            new_future.await
         },
     }
 }
@@ -59,31 +55,29 @@ pub async fn map_ok<Fut, F, T, U, E>(future: Fut, f: F) -> Result<U, E>
     where F: FnOnce(T) -> U,
           Fut: Future<Output = Result<T,E>>,
 {
-    let future_result = await!(future);
-    future_result.map(f)
+    future.await.map(f)
 }
 
 pub async fn map_err<Fut, F, T, E, U>(future: Fut, f: F) -> Result<T, U>
     where F: FnOnce(E) -> U,
           Fut: Future<Output = Result<T,E>>,
 {
-    let future_result = await!(future);
-    future_result.map_err(f)
+    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 = await!(future);
-    await!(nested_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 = await!(future);
+    let future_result = future.await;
     f(&future_result);
     future_result
 }
@@ -92,16 +86,14 @@ pub async fn err_into<Fut, T, E, U>(future: Fut) -> Result<T,U>
     where Fut: Future<Output = Result<T,E>>,
           E: Into<U>,
 {
-    let future_result = await!(future);
-    future_result.map_err(Into::into)
+    future.await.map_err(Into::into)
 }
 
 pub async fn unwrap_or_else<Fut, T, E, F>(future: Fut, f: F) -> T
     where Fut: Future<Output = Result<T,E>>,
           F: FnOnce(E) -> T,
 {
-    let future_result = await!(future);
-    future_result.unwrap_or_else(f)
+    future.await.unwrap_or_else(f)
 }
 
 pub fn flatten_stream<Fut, St, T>(future: Fut) -> impl Stream<Item = T>
@@ -112,13 +104,13 @@ pub fn flatten_stream<Fut, St, T>(future: Fut) -> impl Stream<Item = T>
     futures::stream::unfold((Some(future), None), async move | (future, stream)| {
         match (future, stream) {
             (Some(future), None) => {
-                let stream = await!(future);
+                let stream = future.await;
                 let mut stream = Box::pin(stream);
-                let item = await!(next(&mut stream));
+                let item = next(&mut stream).await;
                 item.map(|item| (item, (None, Some(stream))))
             },
             (None, Some(mut stream)) => {
-                let item = await!(next(&mut stream));
+                let item = next(&mut stream).await;
                 item.map(|item| (item, (None, Some(stream))))
             },
             _ => unreachable!()
@@ -131,7 +123,7 @@ pub fn into_stream<Fut>(future: Fut) -> impl Stream<Item = Fut::Output>
 {
     futures::stream::unfold(Some(future), async move |future| {
         if let Some(future) = future {
-            let item = await!(future);
+            let item = future.await;
             Some((item, (None)))
         } else {
             None
@@ -166,7 +158,7 @@ mod tests {
     fn test_ready() {
         executor::block_on(async {
             let future = ready(1);
-            assert_eq!(await!(future), 1);
+            assert_eq!(future.await, 1);
         });
     }
 
@@ -175,7 +167,7 @@ mod tests {
         executor::block_on(async {
             let future = ready(1);
             let new_future = map(future, |x| x + 3);
-            assert_eq!(await!(new_future), 4);
+            assert_eq!(new_future.await, 4);
         });
     }
 
@@ -184,7 +176,7 @@ mod tests {
         executor::block_on(async {
             let future = ready(1);
             let new_future = then(future, |x| ready(x + 3));
-            assert_eq!(await!(new_future), 4);
+            assert_eq!(new_future.await, 4);
         });
     }
 
@@ -193,7 +185,7 @@ mod tests {
         executor::block_on(async {
             let future = ready(Ok::<i32, i32>(1));
             let new_future = and_then(future, |x| ready(Ok::<i32, i32>(x + 3)));
-            assert_eq!(await!(new_future), Ok(4));
+            assert_eq!(new_future.await, Ok(4));
         });
     }
 
@@ -202,7 +194,7 @@ mod tests {
         executor::block_on(async {
             let future = ready(Err::<i32, i32>(1));
             let new_future = or_else(future, |x| ready(Err::<i32, i32>(x + 3)));
-            assert_eq!(await!(new_future), Err(4));
+            assert_eq!(new_future.await, Err(4));
         });
     }
 
@@ -211,7 +203,7 @@ mod tests {
         executor::block_on(async {
             let future = ready(Ok::<i32, i32>(1));
             let new_future = map_ok(future, |x| x + 3);
-            assert_eq!(await!(new_future), Ok(4));
+            assert_eq!(new_future.await, Ok(4));
         });
     }
 
@@ -220,7 +212,7 @@ mod tests {
         executor::block_on(async {
             let future = ready(Err::<i32, i32>(1));
             let new_future = map_err(future, |x| x + 3);
-            assert_eq!(await!(new_future), Err(4));
+            assert_eq!(new_future.await, Err(4));
         });
     }
 
@@ -229,7 +221,7 @@ mod tests {
         executor::block_on(async {
             let nested_future = ready(ready(1));
             let future = flatten(nested_future);
-            assert_eq!(await!(future), 1);
+            assert_eq!(future.await, 1);
         });
     }
 
@@ -238,7 +230,7 @@ mod tests {
         executor::block_on(async {
             let future = ready(1);
             let new_future = inspect(future, |&x| assert_eq!(x, 1));
-            assert_eq!(await!(new_future), 1);
+            assert_eq!(new_future.await, 1);
         });
     }
 
@@ -248,7 +240,7 @@ mod tests {
             let future_err_u8 = ready(Err::<(), u8>(1));
             let future_err_i32 = err_into::<_, _, _, i32>(future_err_u8);
 
-            assert_eq!(await!(future_err_i32), Err::<(), i32>(1));
+            assert_eq!(future_err_i32.await, Err::<(), i32>(1));
         });
     }
 
@@ -257,7 +249,7 @@ mod tests {
         executor::block_on(async {
             let future = ready(Err::<(), &str>("Boom!"));
             let new_future = unwrap_or_else(future, |_| ());
-            assert_eq!(await!(new_future), ());
+            assert_eq!(new_future.await, ());
         });
     }
 
@@ -269,7 +261,7 @@ mod tests {
             let future_of_a_stream = ready(iter(stream_items));
 
             let stream = flatten_stream(future_of_a_stream);
-            let list: Vec<_> = await!(collect(stream));
+            let list: Vec<_> = collect(stream).await;
             assert_eq!(list, vec![17, 18, 19]);
         });
     }
@@ -280,7 +272,7 @@ mod tests {
         executor::block_on(async {
             let future = ready(17);
             let stream = into_stream(future);
-            let collected: Vec<_> = await!(collect(stream));
+            let collected: Vec<_> = collect(stream).await;
             assert_eq!(collected, vec![17]);
         });
     }
@@ -293,7 +285,7 @@ mod tests {
             };
 
             let read_future = poll_fn(read_line);
-            assert_eq!(await!(read_future), "Hello, World!".to_owned());
+            assert_eq!(read_future.await, "Hello, World!".to_owned());
         });
     }
 

src/lib.rs

@@ -1,4 +1,4 @@
-#![feature(async_await, await_macro, gen_future, generators)]
+#![feature(async_await, gen_future, generators)]
 
 pub mod future;
 pub mod stream;