yesml.rbnf

START : <BOF> Top <EOF>;
Top   : !stmts=Stmts -> Top(list(stmts));

Stmts    : !a=Stmt          -> Cons(a, nil);
Stmts    : !a=Stmt !b=Stmts -> Cons(a, b);

Stmt  : !it=(Let | Do | Open) -> it;

Do    : 'do' !exp=Exp                    -> Do(exp);
Let   : 'let' 'rec' !it=LetSeq           -> Let(MKLRCommaList(it), true);
Let   : 'let' !it=LetSeq                 -> Let(MKLRCommaList(it), false);

Bind   : !ident=Id '=' !exp=Exp          -> Bind(ident, exp);
LetSeq : [LetSeq 'and'] Bind;

Open  : 'open' !ident=Id                  -> OpenId(ident);
Open  : 'open' !string=<str>              -> OpenString(MKStr(string));

Exp      : !it=BlockExp                  -> BlockExpr(MKLRCommaList(it));

BlockExp : [BlockExp ';'] OrExp;

OrExp      : !it=OrExpRoot -> Or(MKLRCommaList(it));
OrExpRoot  : [OrExpRoot '||'] AndExp;

AndExp      : !it=AndExpRoot -> And(MKLRCommaList(it));
AndExpRoot  : [AndExpRoot '&&'] BinOp;

BinOp   : !it=(App | LetExp | IfExp)           -> it;
BinOp   : !left=BinOp '`' !op=Id '`' !right=(App | LetExp | IfExp) -> App(op, Tuple2(left, right));

CommaExps : [CommaExps ','] Exp;

LetExp : !let=Let 'in' !exp=Exp                  -> LetExp(let, exp);
IfExp  : 'if' !cond=Exp 'then' !tC=Exp 'else' !fC=Exp -> IfExp(cond, tC, fC);

App     : !a=AtomExp                               -> a;
App     : !f=App '(' !args=CommaExps ')'           -> App(f, MKLRCommaList(args));
App     : !f=App '(' ')'                           -> App(f, Tuple0);
App     : !f=App !arg=Lit                           -> App(f, Tuple1(arg));

AtomExp : !it=(Lam | Match | Nest)                  -> it;

Lam     : ('fn' | 'fun') '(' !args=CommaIds ')' '->' !exp=Exp ['end'] -> Lam(MKLRCommaList(args), exp);
Lam     : ('fn' | 'fun') !arg=Id '->' !exp=Exp ['end']                 -> Lam(Tuple1(arg), exp);
Lam     : ('fn' | 'fun') '(' ')' '->' !exp=Exp ['end']                -> Lam(Tuple0, exp);

Id      : !a=<identifier>  -> MKIdent(a);
Ids     : !hd=Id           -> Cons(hd, nil);
Ids     : !hd=Id !tl=Ids   -> Cons(hd, tl);
CommaIds  : [CommaIds ','] Id;


SymExpr : !a=<sym>       -> SymExpr(MKSym(a));
ChrExpr : !a=<chr>       -> ChrExpr(MKStr(a));
NumExpr : !a=<number>    -> NumExpr(MKNum(a));
StrExpr : !a=<str>       -> StrExpr(MKStr(a));
BoolExpr : !a=('true'|'false') -> BoolExpr(MKBool(a));


Nest   : '(' !hd=Exp ')'                   -> hd;
Nest   : !hd=Lit                           -> hd;

Lit     : !a=(Id | SymExpr | BoolExpr | NumExpr | StrExpr | ChrExpr | List) -> a;


List   : '[' !a=CommaExps <cons> !tl=Exp ']' -> List(MKLRCommaList(a), tl);
List   : '[' !a=CommaExps ']'              -> List(MKLRCommaList(a), none);
List   : '[' ']'                           -> List(Tuple0, none);

Match : "match" !exp=Exp "with" !cases=CaseExps ['end']
      -> Match(exp, MKLRList(cases));

CaseExps   : [CaseExps] CaseExp;

CaseExp    : '|' !case=Case '->' !exp=Exp -> Tuple3(case, none, exp);
CaseExp    : '|' !case=Case 'when' !guard=Exp '->' !exp=Exp -> Tuple3(case, guard, exp);

Case       : !a=OrCase -> MKOrCase(MKLRCommaList(a));
OrCase     : [OrCase '|'] AndCaseRoot;

AndCaseRoot : !a=AndCase -> MKAndCase(MKLRCommaList(a));
AndCase     : [AndCase '&'] AtomCase;

CommaCases : [CommaCases ','] Case;

AtomCase    : !a=(NumCase | SymCase | BoolCase | ChrCase | StrCase | ListCase | NestCase | Id) -> a;

SymCase    : !a=<sym>      -> SymCase(MKSym(a));
ChrCase    : !s=<chr>      -> ChrCase(MKStr(s));
NumCase    : !n=<number>   -> NumCase(MKNum(n));
StrCase    : !s=<str>      -> StrCase(MKStr(s));
BoolCase    : !a=('true'|'false') -> BoolCase(MKBool(a));

ListCase   : '[' !a=CommaCases <cons> !tl=Case ']' -> ListCase(MKLRCommaList(a), tl);
ListCase   : '[' !a=CommaCases ']'              -> ListCase(MKLRCommaList(a), none);
ListCase   : '[' ']'                            -> ListCase(Tuple0, none);

NestCase  : '(' !hd=Case ')' -> hd;