Compare commits

...

1 Commits

Author SHA1 Message Date
Mahmoud Al-Qudsi 8407651a3d Illustrating alexcrichton/futures-rs#683 2017-12-24 18:57:00 -06:00
2 changed files with 52 additions and 13 deletions

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

@ -2,19 +2,50 @@
extern crate futures; extern crate futures;
extern crate tokio_core; extern crate tokio_core;
use futures::future::{self}; use futures::future::{self, FutureResult};
use futures::future::*; use futures::future::*;
use tokio_core::reactor::Core; use tokio_core::reactor::Core;
#[derive(Debug)]
enum ErrorCode
{
CanHandleWithAsync,
CanHandleWithSync,
CannotHandle
}
#[derive(Debug)]
enum ErrorCode2
{
}
fn main() { fn main() {
let mut core = Core::new().expect("Failed to initialize tokio_core reactor!"); let mut core = Core::new().expect("Failed to initialize tokio_core reactor!");
let f = test(); 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),
}
})
;
core.run(f).unwrap(); core.run(f).unwrap();
} }
fn test() -> MapErr<(), ()> { fn async_entry_point() -> FutureResult<(), ErrorCode> {
future::ok(())
}
fn async_error_handler() -> FutureResult<(), ErrorCode2> {
future::ok(()) future::ok(())
.map_err(|String| ())
} }
fn sync_error_handler() -> Result<(), ErrorCode> {
Ok(())
}