// Parser for the lambda calculus
ometa LCParser <: Parser {
digit    = ^digit:d                 -> d.digitValue(),

number   = number:n digit:d         -> (n * 10 + d)
         | digit,
         
addExpr  = addExpr:x "+" mulExpr:y  -> ['add', x, y]
         | addExpr:x "-" mulExpr:y  -> ['sub', x, y]         
         | mulExpr,
         
mulExpr  = mulExpr:x "*" powExpr:y  -> ['mul', x, y]
         | mulExpr:x "/" powExpr:y  -> ['div', x, y]
         | powExpr,

powExpr  = powExpr:x "^" relExpr:y  -> ['pow', x, y]
         | relExpr,

relExpr  = relExpr:x ">" logExpr:y  -> ['gt', x, y]
         | relExpr:x "<" logExpr:y  -> ['lt', x, y]
         | relExpr:x ">=" logExpr:y -> ['gte', x, y]
         | relExpr:x "<=" logExpr:y -> ['lte', x, y]
         | relExpr:x "=" logExpr:y  -> ['eq', x, y]
         | relExpr:x "!=" logExpr:y -> ['neq', x, y]
         | logExpr,

logExpr  = logExpr:x "and" primExpr:y -> ['and', x, y]
         | logExpr:x "or" primExpr:y  -> ['or', x, y]
         | logExpr:x "xor" primExpr:y -> ['xor', x, y]
         | "not" logExpr:x            -> ['not', x]
         | primExpr,
         
spaces  = ' '*,

primExpr = '(' expr:x ')'           -> x
         | spaces iName:nn spaces   -> ['name', nn]
         | spaces number:n spaces   -> ['num', n],

nameFirst    = letter,
nameRest     = nameFirst | digit,
iName        = firstAndRest(#nameFirst, #nameRest):r -> r.join(''),

expr = addExpr:e -> [e],

root = root:r  ';' expr:ef -> r.concat(ef)
     | expr:e -> e

}
p=LCParser.matchAll("x and y;x*y", "root")
alert(p)