test.rs

enum Result<S, R, F> {
    Success(R, ~[S]),
    Failure(F)
}

struct Parser<'a, S, R, F> { parse : 'a |&[S]| -> Result<S,R,F> }

trait Composable {
    fn Or(Self, Self) -> Self;
}

impl<'a, S, R, F> Composable for Parser<'a, S, R, F> {
    fn Or
        ( p1 : Parser<'a, S, R, F>
        , p2 : Parser<'a, S, R, F>
        ) -> Parser<'a, S, R, F> {
            Parser
                { parse: |stream : &[S]| -> Result<S,R,F>
                    { let result = (p1.parse)(stream)
                    ; match result
                        { Failure(_) => (p2.parse)(stream)
                        , _ => result
                        }
                    }
                }
    }
}

fn main() {
    // let p = Parser { parse: |stream : &[int]| -> ~[Result<]};

    println!("test");
}