Sun Jun 26 21:16:15 JST 2016

type ParseResult = Option<(Vec<char>, Vec<char>)>;
struct Parser(Box<Fn(&Vec<char>) -> ParseResult>);

fn one_of(c: char) -> Parser {
    Parser(Box::new(move |cs: &Vec<char>| {
        if cs.len() == 0 || cs[0] != c {
            None
        } else {
            Some((vec![c], cs[1..].to_owned()))
        }
    }))
}

impl Parser {
    fn call(&self, s: String) -> ParseResult {
        let Parser(ref f) = *self;
        let chars = s.chars().collect::<Vec<_>>();
        f(&chars)
    }
}

    let parser = one_of('a');
    let s = String::from("abc");
    println!("{:?}", parser.call(s));

Some((['a'], ['b', 'c']))

fn string(s: String) -> Parser {
    let ds: Vec<char> = s.chars().collect();
    Parser(Box::new(move |cs: &Vec<char>| {
        let n = ds.len();
        if cs.len() < n { return None }
        for i in 0..n {
            if ds[i] != cs[i] { return None }
        }
        Some((ds.to_owned(), cs[n..].to_owned()))
    }))
}

    let parser = one_of('a') / one_of('b'); // 'a' を読む. 失敗したら、'b' を読む
    {
        let s = String::from("abc");
        println!("{:?}", parser.call(s));
    }
    {
        let s = String::from("bbc");
        println!("{:?}", parser.call(s));
    }
    {
        let s = String::from("cbc"); // fails
        println!("{:?}", parser.call(s));
    }

Some((['a'], ['b', 'c']))
Some((['b'], ['b', 'c']))
None

fn choice(p1: Parser, p2: Parser) -> Parser {
    let Parser(f1) = p1;
    let Parser(f2) = p2;
    Parser(Box::new(move |cs: &Vec<char>| {
        if let Some(a) = f1(&cs) {
            Some(a)
        } else {
            f2(&cs)
        }
    }))
}

use std::ops::Div;
impl Div for Parser {
    type Output = Parser;
    fn div(self, rhs: Parser) -> Parser { choice(self, rhs) }
}

fn then(p1: Parser, p2: Parser) -> Parser {
    let Parser(f1) = p1;
    let Parser(f2) = p2;
    Parser(Box::new(move |cs: &Vec<char>| {
        if let Some((xs, ys)) = f1(&cs) {
            if let Some((xs2, ys2)) = f2(&ys) {
                let mut mxs = xs.clone();
                let mut mxs2 = xs2.clone();
                mxs.append(&mut mxs2);
                return Some((mxs.to_owned(), ys2))
            }
        }
        None
    }))
}

use std::ops::Add;
impl Add for Parser {
    type Output = Parser;
    fn add(self, rhs: Parser) -> Parser { then(self, rhs) }
}

    let parser = (string(String::from("A")) / string(String::from("The"))) + one_of(' ') + string(String::from("cat"));
    {
        let s = String::from("My cat"); // fails
        println!("{:?}", parser.call(s));
    }
    {
        let s = String::from("The cat");
        println!("{:?}", parser.call(s));
    }
}

None
Some((['T', 'h', 'e', ' ', 'c', 'a', 't'], []))