cargo.out

@@ -1,22 +1,14 @@
-   Compiling futuretest v0.1.0 (file:///mnt/d/GIT/futuretest)
-error[E0308]: match arms have incompatible types
-  --> src/main.rs:28:13
+   Compiling futuretest v0.1.0 (file:///mnt/c/Users/Mahmoud/git/futuretest)
+error[E0277]: the trait bound `(): futures::Future` is not satisfied
+  --> src/main.rs:17:1
    |
-28 | /             match err {
-29 | |                 ErrorCode::CanHandleWithAsync => async_error_handler()
-30 | |                     .map_err(|_| ErrorCode::CannotHandle).wait(),
-31 | |                 ErrorCode::CanHandleWithSync => future::result(sync_error_handler()),
-32 | |                 ErrorCode::CannotHandle => future::err(ErrorCode::CannotHandle),
-33 | |             }
-   | |_____________^ expected enum `std::result::Result`, found struct `futures::FutureResult`
+17 | / fn test() -> MapErr<(), ()> {
+18 | |     future::ok(())
+19 | |         .map_err(|String| ())
+20 | | }
+   | |_^ the trait `futures::Future` is not implemented for `()`
    |
-   = note: expected type `std::result::Result<(), ErrorCode>`
-              found type `futures::FutureResult<(), ErrorCode>`
-note: match arm with an incompatible type
-  --> src/main.rs:31:49
-   |
-31 |                 ErrorCode::CanHandleWithSync => future::result(sync_error_handler()),
-   |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: required by `futures::MapErr`
 
 error: aborting due to previous error
 

src/main.rs

@@ -2,50 +2,19 @@
 
 extern crate futures;
 extern crate tokio_core;
-use futures::future::{self, FutureResult};
+use futures::future::{self};
 use futures::future::*;
 use tokio_core::reactor::Core;
 
-#[derive(Debug)]
-enum ErrorCode
-{
-    CanHandleWithAsync,
-    CanHandleWithSync,
-    CannotHandle
-}
-
-#[derive(Debug)]
-enum ErrorCode2
-{
-}
-
 fn main() {
     let mut core = Core::new().expect("Failed to initialize tokio_core reactor!");
 
-    let f = async_entry_point()
-        .or_else(move |err| {
-            //the problem is that the three matches below resolve to different future types
-            match err {
-                ErrorCode::CanHandleWithAsync => async_error_handler()
-                    .map_err(|_| ErrorCode::CannotHandle).wait(),
-                ErrorCode::CanHandleWithSync => future::result(sync_error_handler()),
-                ErrorCode::CannotHandle => future::err(ErrorCode::CannotHandle),
-            }
-        })
-    ;
+    let f = test();
 
     core.run(f).unwrap();
 }
 
-fn async_entry_point() -> FutureResult<(), ErrorCode> {
-    future::ok(())
-}
-
-fn async_error_handler() -> FutureResult<(), ErrorCode2> {
+fn test() -> MapErr<(), ()> {
     future::ok(())
+        .map_err(|String| ())
 }
-
-fn sync_error_handler() -> Result<(), ErrorCode> {
-    Ok(())
-}
-