Mahmoud Al-Qudsi 4 years ago
parent
commit
8407651a3d
  1. 26
      cargo.out
  2. 39
      src/main.rs

26
cargo.out

@ -1,14 +1,22 @@
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
Compiling futuretest v0.1.0 (file:///mnt/d/GIT/futuretest)
error[E0308]: match arms have incompatible types
--> src/main.rs:28:13
|
17 | / fn test() -> MapErr<(), ()> {
18 | | future::ok(())
19 | | .map_err(|String| ())
20 | | }
| |_^ the trait `futures::Future` is not implemented for `()`
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`
|
= 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

39
src/main.rs

@ -2,19 +2,50 @@
extern crate futures;
extern crate tokio_core;
use futures::future::{self};
use futures::future::{self, FutureResult};
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 = 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();
}
fn test() -> MapErr<(), ()> {
fn async_entry_point() -> FutureResult<(), ErrorCode> {
future::ok(())
}
fn async_error_handler() -> FutureResult<(), ErrorCode2> {
future::ok(())
.map_err(|String| ())
}
fn sync_error_handler() -> Result<(), ErrorCode> {
Ok(())
}
Loading…
Cancel
Save