init

Author: Roman Proskuryakov

.gitignore

@@ -0,0 +1,3 @@
+/target
+**/*.rs.bk
+Cargo.lock

.travis.yml

@@ -0,0 +1,7 @@
+language: rust
+sudo: false
+rust:
+  - nightly-2019-02-19
+
+os:
+ - linux

Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "futures-async-combinators"
+version = "0.1.0"
+authors = ["Roman Proskuryakov <humbug@deeptown.org>"]
+edition = "2018"
+
+[dependencies]
+
+[dependencies.futures]
+version = "=0.3.0-alpha.13"
+package = "futures-preview"

LICENSE

@@ -0,0 +1,24 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.NGS IN THE SOFTWARE.
+

README.md

@@ -0,0 +1,66 @@
+# futures-async-combinators
+
+[![Build Status](https://travis-ci.com/kpp/futures-async-combinators.svg?branch=master)](https://travis-ci.com/kpp/futures-async-combinators)
+
+FOR LEARNING PURPOSES ONLY
+
+This is a greatly simplified implementation of [https://docs.rs/futures-preview/0.3.0-alpha.13/futures/](Future combinators)
+like `FutureExt::map`, `TryFutureExt::and_then`...
+
+# Requirements
+
+Rust nightly-2019-02-19 for async_await, await_macro...
+
+# Why
+
+To understand how combinators work by looking at clean source code. Compare:
+
+```rust
+pub async fn then<...>(future, f) -> ...
+{
+    let future_result = await!(future);
+    let new_future = f(future_result);
+    await!(new_future)
+}
+```
+
+with original
+
+```rust
+impl Then
+{
+    fn poll(self, waker) -> Poll<...> {
+        self.as_mut().chain().poll(waker, |output, f| f(output))
+    }
+}
+
+impl Chain
+{
+    fn poll(self, waker, f) -> Poll<...>
+    {
+        let mut f = Some(f);
+
+        // Safe to call `get_unchecked_mut` because we won't move the futures.
+        let this = unsafe { Pin::get_unchecked_mut(self) };
+
+        loop {
+            let (output, data) = match this {
+                Chain::First(fut1, data) => {
+                    match unsafe { Pin::new_unchecked(fut1) }.poll(waker) {
+                        Poll::Pending => return Poll::Pending,
+                        Poll::Ready(output) => (output, data.take().unwrap()),
+                    }
+                }
+                Chain::Second(fut2) => {
+                    return unsafe { Pin::new_unchecked(fut2) }.poll(waker);
+                }
+                Chain::Empty => unreachable!()
+            };
+
+            *this = Chain::Empty; // Drop fut1
+            let fut2 = (f.take().unwrap())(output, data);
+            *this = Chain::Second(fut2)
+        }
+    }
+}
+```

src/future.rs

@@ -0,0 +1,161 @@
+use futures::future::Future;
+
+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)
+}
+
+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)
+}
+
+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 {
+        Ok(ok) => {
+            let new_future = f(ok);
+            await!(new_future)
+        },
+        Err(err) => Err(err),
+    }
+}
+
+pub async fn or_else<FutA, FutB, F, T, E, U>(future: FutA, f: F) -> Result<T, U>
+    where F: FnOnce(E) -> FutB,
+          FutA: Future<Output = Result<T,E>>,
+          FutB: Future<Output = Result<T,U>>,
+{
+    let future_result = await!(future);
+    match future_result {
+        Ok(ok) => Ok(ok),
+        Err(err) => {
+            let new_future = f(err);
+            await!(new_future)
+        },
+    }
+}
+
+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)
+}
+
+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)
+}
+
+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)
+}
+
+pub async fn inspect<Fut, F>(future: Fut, f: F) -> Fut::Output
+    where Fut: Future,
+          F: FnOnce(&Fut::Output),
+{
+    let future_result = await!(future);
+    f(&future_result);
+    future_result
+}
+
+
+#[cfg(test)]
+mod tests {
+    use futures::{future, executor};
+    use crate::future::*;
+
+    #[test]
+    fn test_map() {
+        executor::block_on(async {
+            let future = future::ready(1);
+            let new_future = map(future, |x| x + 3);
+            assert_eq!(await!(new_future), 4);
+        });
+    }
+
+    #[test]
+    fn test_then() {
+        executor::block_on(async {
+            let future = future::ready(1);
+            let new_future = then(future, |x| future::ready(x + 3));
+            assert_eq!(await!(new_future), 4);
+        });
+    }
+
+    #[test]
+    fn test_and_then() {
+        executor::block_on(async {
+            let future = future::ready(Ok::<i32, i32>(1));
+            let new_future = and_then(future, |x| future::ready(Ok::<i32, i32>(x + 3)));
+            assert_eq!(await!(new_future), Ok(4));
+        });
+    }
+
+    #[test]
+    fn test_or_else() {
+        executor::block_on(async {
+            let future = future::ready(Err::<i32, i32>(1));
+            let new_future = or_else(future, |x| future::ready(Err::<i32, i32>(x + 3)));
+            assert_eq!(await!(new_future), Err(4));
+        });
+    }
+
+    #[test]
+    fn test_map_ok() {
+        executor::block_on(async {
+            let future = future::ready(Ok::<i32, i32>(1));
+            let new_future = map_ok(future, |x| x + 3);
+            assert_eq!(await!(new_future), Ok(4));
+        });
+    }
+
+    #[test]
+    fn test_map_err() {
+        executor::block_on(async {
+            let future = future::ready(Err::<i32, i32>(1));
+            let new_future = map_err(future, |x| x + 3);
+            assert_eq!(await!(new_future), Err(4));
+        });
+    }
+
+    #[test]
+    fn test_flatten() {
+        executor::block_on(async {
+            let nested_future = future::ready(future::ready(1));
+            let future = flatten(nested_future);
+            assert_eq!(await!(future), 1);
+        });
+    }
+
+    #[test]
+    fn test_inspect() {
+        executor::block_on(async {
+            let future = future::ready(1);
+            let new_future = inspect(future, |&x| assert_eq!(x, 1));
+            assert_eq!(await!(new_future), 1);
+        });
+    }
+}

src/lib.rs

@@ -0,0 +1,3 @@
+#![feature(async_await, await_macro, futures_api)]
+
+pub mod future;