a.rs

#[async]
fn long_running_future(timer: Timer, a: u64) -> impl Future<Item=u64, Error=TimerError> {
    for i in 0..10 {
        let sleep_time = i * a;
        if i % 2 == 0 {
            println!("sleeping {}: {}", i, sleep_time);
            await!(timer.sleep(Duration::from_millis(sleep_time)));
        }
    }

    println!("done sleeping");

    a
}

b.rs

fn long_running_future(timer: Timer, a: u64) -> Box<Future<Item = u64, Error = TimerError>> {
    struct StateMachine<S, F> {
        state: S,
        next: F,
    }
    impl<S, F, Item, Error> StateMachine<S, F>
        where S: ::std::default::Default,
              F: Fn(S) -> ::std::result::Result<(::futures::Async<Item>, S), Error>
    {
        fn new(initial_state: S, next: F) -> Self {
            StateMachine {
                state: initial_state,
                next: next,
            }
        }
    }
    impl<S, F, Item, Error> ::futures::Future for StateMachine<S, F>
        where S: ::std::default::Default,
              F: Fn(S) -> ::std::result::Result<(::futures::Async<Item>, S), Error>
    {
        type Item = Item;
        type Error = Error;
        fn poll(&mut self) -> ::futures::Poll<Item, Error> {
            let state = ::std::mem::replace(&mut self.state, S::default());
            let (value, state) = try!((self.next)(state));
            self.state = state;
            Ok(value)
        }
    }
    enum State<T0, T1, T2, T3, T4, T5, T6, T7> {
        Illegal,
        State0Start { timer: T0, a: T1 },
        State1End { return_: T2 },
        State2Loop {
            timer: T0,
            a: T1,
            __stateful_iter: T3,
        },
        State3LoopExit {
            timer: T0,
            a: T1,
            __stateful_iter: T3,
        },
        State4Arm {
            timer: T0,
            a: T1,
            __stateful_iter: T3,
            i: T4,
        },
        State5Arm {
            timer: T0,
            a: T1,
            __stateful_iter: T3,
        },
        State6MatchJoin {
            timer: T0,
            a: T1,
            __stateful_iter: T3,
        },
        State7Then {
            timer: T0,
            a: T1,
            __stateful_iter: T3,
            i: T4,
            sleep_time: T5,
        },
        State8Else {
            timer: T0,
            a: T1,
            __stateful_iter: T3,
            i: T4,
            sleep_time: T5,
        },
        State9AwaitLoop {
            timer: T0,
            a: T1,
            __stateful_iter: T3,
            i: T4,
            sleep_time: T5,
            future: T6,
        },
        State10AwaitExit {
            timer: T0,
            a: T1,
            __stateful_iter: T3,
            i: T4,
            sleep_time: T5,
            future: T6,
        },
        State11AwaitReady {
            timer: T0,
            a: T1,
            __stateful_iter: T3,
            i: T4,
            sleep_time: T5,
            future: T6,
            result: T7,
        },
        State12EndScope {
            timer: T0,
            a: T1,
            __stateful_iter: T3,
            i: T4,
            sleep_time: T5,
            future: T6,
        },
        State13AwaitNotReady {
            timer: T0,
            a: T1,
            __stateful_iter: T3,
            i: T4,
            sleep_time: T5,
            future: T6,
        },
        State14EndScope {
            timer: T0,
            a: T1,
            __stateful_iter: T3,
            i: T4,
            sleep_time: T5,
        },
        State15IfJoin {
            timer: T0,
            a: T1,
            __stateful_iter: T3,
            i: T4,
            sleep_time: T5,
        },
        State16EndScope {
            timer: T0,
            a: T1,
            __stateful_iter: T3,
            i: T4,
        },
        State17EndScope {
            timer: T0,
            a: T1,
            __stateful_iter: T3,
        },
        State18EndScope {
            timer: T0,
            a: T1,
            __stateful_iter: T3,
        },
        State19EndScope { timer: T0, a: T1 },
        State20EndScope { timer: T0, a: T1, return_: T2 },
    }
    impl<T0, T1, T2, T3, T4, T5, T6, T7> ::std::default::Default for State<T0,
                                                                           T1,
                                                                           T2,
                                                                           T3,
                                                                           T4,
                                                                           T5,
                                                                           T6,
                                                                           T7> {
        fn default() -> Self {
            State::Illegal
        }
    }
    Box::new(StateMachine::new(State::State0Start {
                                   timer: timer,
                                   a: a,
                               },
                               |mut state| {
        loop {
            match state {
                State::State0Start { timer, a } => {
                    let __stateful_iter;
                    __stateful_iter = ::std::iter::IntoIterator::into_iter(0..10);
                    state = State::State2Loop {
                        timer: timer,
                        a: a,
                        __stateful_iter: __stateful_iter,
                    };
                    continue;
                }
                State::State1End { return_ } => {
                    return ::std::result::Result::Ok((::futures::Async::Ready(return_),
                                                      State::Illegal));
                }
                State::State2Loop { timer, a, mut __stateful_iter } => {
                    match __stateful_iter.next() {
                        ::std::option::Option::Some(i) => {
                            state = State::State4Arm {
                                timer: timer,
                                a: a,
                                __stateful_iter: __stateful_iter,
                                i: i,
                            };
                            continue;
                        }
                        ::std::option::Option::None => {
                            state = State::State5Arm {
                                timer: timer,
                                a: a,
                                __stateful_iter: __stateful_iter,
                            };
                            continue;
                        }
                    }
                }
                State::State3LoopExit { timer, a, mut __stateful_iter } => {
                    let _stmt_result_temp = ();
                    ::std::mem::drop(__stateful_iter);
                    state = State::State19EndScope {
                        timer: timer,
                        a: a,
                    };
                    continue;
                }
                State::State4Arm { timer, a, mut __stateful_iter, i } => {
                    let sleep_time;
                    sleep_time = i * a;
                    if i % 2 == 0 {
                        state = State::State7Then {
                            timer: timer,
                            a: a,
                            __stateful_iter: __stateful_iter,
                            i: i,
                            sleep_time: sleep_time,
                        };
                        continue;
                    } else {
                        state = State::State8Else {
                            timer: timer,
                            a: a,
                            __stateful_iter: __stateful_iter,
                            i: i,
                            sleep_time: sleep_time,
                        };
                        continue;
                    }
                }
                State::State5Arm { timer, a, mut __stateful_iter } => {
                    state = State::State3LoopExit {
                        timer: timer,
                        a: a,
                        __stateful_iter: __stateful_iter,
                    };
                    continue;
                }
                State::State6MatchJoin { timer, a, mut __stateful_iter } => {
                    state = State::State18EndScope {
                        timer: timer,
                        a: a,
                        __stateful_iter: __stateful_iter,
                    };
                    continue;
                }
                State::State7Then { timer, a, mut __stateful_iter, i, sleep_time } => {
                    println!("sleeping {}: {}", i, sleep_time);
                    let future;
                    future = timer.sleep(Duration::from_millis(sleep_time));
                    state = State::State9AwaitLoop {
                        timer: timer,
                        a: a,
                        __stateful_iter: __stateful_iter,
                        i: i,
                        sleep_time: sleep_time,
                        future: future,
                    };
                    continue;
                }
                State::State8Else { timer, a, mut __stateful_iter, i, sleep_time } => {
                    state = State::State15IfJoin {
                        timer: timer,
                        a: a,
                        __stateful_iter: __stateful_iter,
                        i: i,
                        sleep_time: sleep_time,
                    };
                    continue;
                }
                State::State9AwaitLoop { timer,
                                         a,
                                         mut __stateful_iter,
                                         i,
                                         sleep_time,
                                         mut future } => {
                    match match ::futures::Future::poll(&mut future) {
                        ::std::result::Result::Ok(value) => value,
                        ::std::result::Result::Err(value) => {
                            return ::std::result::Result::Err(value)
                        }
                    } {
                        ::futures::Async::Ready(result) => {
                            state = State::State11AwaitReady {
                                timer: timer,
                                a: a,
                                __stateful_iter: __stateful_iter,
                                i: i,
                                sleep_time: sleep_time,
                                future: future,
                                result: result,
                            };
                            continue;
                        }
                        ::futures::Async::NotReady => {
                            state = State::State13AwaitNotReady {
                                timer: timer,
                                a: a,
                                __stateful_iter: __stateful_iter,
                                i: i,
                                sleep_time: sleep_time,
                                future: future,
                            };
                            continue;
                        }
                    }
                }
                State::State10AwaitExit { timer,
                                          a,
                                          mut __stateful_iter,
                                          i,
                                          sleep_time,
                                          mut future } => {
                    let _loop_result_temp = ();
                    ::std::mem::drop(future);
                    state = State::State14EndScope {
                        timer: timer,
                        a: a,
                        __stateful_iter: __stateful_iter,
                        i: i,
                        sleep_time: sleep_time,
                    };
                    continue;
                }
                State::State11AwaitReady { timer,
                                           a,
                                           mut __stateful_iter,
                                           i,
                                           sleep_time,
                                           mut future,
                                           result } => {
                    ::std::mem::drop(result);
                    state = State::State12EndScope {
                        timer: timer,
                        a: a,
                        __stateful_iter: __stateful_iter,
                        i: i,
                        sleep_time: sleep_time,
                        future: future,
                    };
                    continue;
                }
                State::State12EndScope { timer,
                                         a,
                                         mut __stateful_iter,
                                         i,
                                         sleep_time,
                                         mut future } => {
                    state = State::State10AwaitExit {
                        timer: timer,
                        a: a,
                        __stateful_iter: __stateful_iter,
                        i: i,
                        sleep_time: sleep_time,
                        future: future,
                    };
                    continue;
                }
                State::State13AwaitNotReady { timer,
                                              a,
                                              mut __stateful_iter,
                                              i,
                                              sleep_time,
                                              mut future } => {
                    return ::std::result::Result::Ok((::futures::Async::NotReady,
                                                      State::State9AwaitLoop {
                        timer: timer,
                        a: a,
                        __stateful_iter: __stateful_iter,
                        i: i,
                        sleep_time: sleep_time,
                        future: future,
                    }));
                }
                State::State14EndScope { timer, a, mut __stateful_iter, i, sleep_time } => {
                    state = State::State15IfJoin {
                        timer: timer,
                        a: a,
                        __stateful_iter: __stateful_iter,
                        i: i,
                        sleep_time: sleep_time,
                    };
                    continue;
                }
                State::State15IfJoin { timer, a, mut __stateful_iter, i, sleep_time } => {
                    ::std::mem::drop(sleep_time);
                    state = State::State16EndScope {
                        timer: timer,
                        a: a,
                        __stateful_iter: __stateful_iter,
                        i: i,
                    };
                    continue;
                }
                State::State16EndScope { timer, a, mut __stateful_iter, i } => {
                    ::std::mem::drop(i);
                    state = State::State17EndScope {
                        timer: timer,
                        a: a,
                        __stateful_iter: __stateful_iter,
                    };
                    continue;
                }
                State::State17EndScope { timer, a, mut __stateful_iter } => {
                    state = State::State6MatchJoin {
                        timer: timer,
                        a: a,
                        __stateful_iter: __stateful_iter,
                    };
                    continue;
                }
                State::State18EndScope { timer, a, mut __stateful_iter } => {
                    state = State::State2Loop {
                        timer: timer,
                        a: a,
                        __stateful_iter: __stateful_iter,
                    };
                    continue;
                }
                State::State19EndScope { timer, a } => {
                    println!("done sleeping");
                    let return_;
                    return_ = a;
                    state = State::State20EndScope {
                        timer: timer,
                        a: a,
                        return_: return_,
                    };
                    continue;
                }
                State::State20EndScope { timer, a, return_ } => {
                    ::std::mem::drop(return_);
                    ::std::mem::drop(a);
                    ::std::mem::drop(timer);
                    state = State::State1End { return_: return_ };
                    continue;
                }
                State::Illegal => unreachable!("illegal state"),
            }
        }
    }))
}