Rust code shared from the playground

playground.rs

extern crate futures;

use futures::{future, Async, Future, Poll};

struct State<T, F: FnMut(T) -> U, U: Future> {
    elements: std::vec::IntoIter<T>,
    func: F,
    current_future: Option<U>,
    errors: Vec<U::Error>,
}

impl<T, F: FnMut(T) -> U, U: Future> Future for State<T, F, U> {
    type Item = U::Item;
    type Error = Vec<U::Error>;

    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        let mut current_future = self.current_future.take();
        if let Some(mut current_future) = current_future {
            match current_future.poll() {
                Ok(Async::NotReady) => {
                    self.current_future = Some(current_future);
                    Ok(Async::NotReady)
                },

                Ok(Async::Ready(v)) =>
                    return Ok(Async::Ready(v)),

                Err(err) => {
                    self.errors.push(err);
                    self.poll()
                },
            }
        }
        else {
            match self.elements.next() {
                Some(v) => {
                    self.current_future = Some((self.func)(v));
                    self.poll()
                },
                None => {
                    let errors = ::std::mem::replace(&mut self.errors, vec![]);
                    Err(errors)
                },
            }
        }
    }
}

fn main() {
}