valid_yet_silly_fut0.rs

#![feature(conservative_impl_trait)]

extern crate futures;

use futures::future::*;

#[derive(Debug)]
struct ErrorA;
#[derive(Debug)]
struct ErrorB;

impl From<ErrorA> for ErrorB {
    fn from(a: ErrorA) -> ErrorB {
        ErrorB {}
    }
}

fn met_a() -> Result<(), ErrorA> {
    Ok(())
}
fn met_b() -> Result<(), ErrorB> {
    met_a()?;
    Ok(())
}

fn io_a() -> impl Future<Item = (), Error = ErrorA> {
    ok(())
}

fn io_b() -> impl Future<Item = (), Error = ErrorB> {
    ok(())
}

fn code() -> impl Future<Item = (), Error = ErrorB> {
    io_a()
        .from_err()
        .and_then(|_| {
            ok({
                met_a()?;
                met_b()?;
            })
        })
        .from_err()
        .and_then(|_| done(met_b()).and_then(|_| io_b()))

}

fn main() {
    let future = code();
}