enum Pattern {
    // matches and consumes
    Literal(~str),
    Range(char, char),
    Set(~[char]),
    Rep(int, ~Pattern),
    Seq(~[Pattern]),
    Or(~[~Pattern]),
    Diff(~Pattern, ~Pattern),
    Match(~Pattern, ~fn(&Pattern) -> int),

    // matches but doesn't consume
    And(~Pattern),

    // consumes but doesn't match
    Chars(int),

    // controls visibility
    All(~Pattern),
    Select(int, ~Pattern),
    Var(~str, ~Pattern),
    Group(~Pattern),
    Pos,
    Constant(~str),
    Fold(~Pattern, ~fn(&Pattern, &Pattern) -> Pattern)
}

struct Token<'self> {
    children: ~[Token<'self>],
    tok: &'self str,
    start: uint,
    end: uint
}

fn parse<'self>(pat: Pattern, text: &'self str, offset: uint) -> Option<Token> {
    match pat {
        Literal(s) => {
            let slc: &'self str = text.slice(offset, s.len());
            if slc == s {
                Some(Token {children: ~[], tok: slc, start: offset, end: offset + s.len()})
            } else {
                None
            }
        }
        _ => None
    }
}