rspg
A simple experimental LR(1) rust parser generator library for syntactic analysis learning.
Status
Usage
Full example: rspg-examples/src/lambda-macros/main.rs.
#[derive(Debug, Clone)]
pub enum Token {
Lambda,
Variable(String),
Point,
LeftBracket,
RightBracket,
}
#[derive(Debug, Clone)]
pub struct Variable(pub String);
#[derive(Debug, Clone)]
pub enum Term {
Variable(Variable),
Abstraction(Variable, Box<Term>),
Application(Box<Term>, Box<Term>),
}
rspg! {
pub mod lambda {
token Token;
terminal "lambda" Token::Lambda => ();
terminal "." Token::Point => ();
terminal "(" Token::LeftBracket => ();
terminal ")" Token::RightBracket => ();
terminal "x" Token::Variable(x) => x;
error ();
start Term;
nonterminal Term: Term;
rule Term -> (t: Abstraction) => Ok(t);
nonterminal Abstraction: Term;
rule Abstraction -> "lambda" (x: Variable) "." (t: Abstraction) =>
Ok(Term::Abstraction(x, Box::new(t)));
rule Abstraction -> (t: Application) => Ok(t);
nonterminal Application: Term;
rule Application -> (t1: Application) (t2: Primary) =>
Ok(Term::Application(Box::new(t1), Box::new(t2)));
rule Application -> (t: Primary) => Ok(t);
nonterminal Primary: Term;
rule Primary -> "(" (t: Term) ")" => Ok(t);
rule Primary -> (x: Variable) => Ok(Term::Variable(x));
nonterminal Variable: Variable;
rule Variable -> (x: "x") => Ok(Variable(x));
}
}
fn main() {
...
let tokens = ...;
match lambda::parse(tokens) {
Ok(t) => {
...
},
Err(e) => {
error!("parse error: {:?}", e);
...
},
}
...
}