futures 0.1.0

An implementation of futures and streams featuring zero allocations, composability, and iterator-like interfaces.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

use {Future, Task, Poll};

pub enum Collapsed<T: Future> {
    Start(T),
    Tail(Box<Future<Item=T::Item, Error=T::Error>>),
}

impl<T: Future> Collapsed<T> {
    pub fn poll(&mut self, task: &mut Task) -> Poll<T::Item, T::Error> {
        match *self {
            Collapsed::Start(ref mut a) => a.poll(task),
            Collapsed::Tail(ref mut a) => a.poll(task),
        }
    }

    pub fn schedule(&mut self, task: &mut Task) {
        match *self {
            Collapsed::Start(ref mut a) => a.schedule(task),
            Collapsed::Tail(ref mut a) => a.schedule(task),
        }
    }

    pub fn collapse(&mut self) {
        let a = match *self {
            Collapsed::Start(ref mut a) => {
                match a.tailcall() {
                    Some(a) => a,
                    None => return,
                }
            }
            Collapsed::Tail(ref mut a) => {
                if let Some(b) = a.tailcall() {
                    *a = b;
                }
                return
            }
        };
        *self = Collapsed::Tail(a);
    }
}