ometa M {
    fact 0                         -> 1,
    fact :n ?(n > 0) fact(n - 1):m -> (n * m)
  }
  M.match(5, "fact")

// a simple recognizer, produces no useful value

ometa L {
  number   = digit+,
  addExpr  = addExpr '+' mulExpr
           | addExpr '-' mulExpr
           | mulExpr,
  mulExpr  = mulExpr '*' primExpr
           | mulExpr '/' primExpr
           | primExpr,
  primExpr = '(' expr ')'
           | number,
  expr     = addExpr
}

L.matchAll('6*(4+3)', 'expr')

// a recognizer that also interprets

ometa Calc {
  digit    = super(#digit):d          -> d.digitValue(),
  number   = number:n digit:d         -> (n * 10 + d)
           | digit,
  addExpr  = addExpr:x '+' mulExpr:y  -> (x + y)
           | addExpr:x '-' mulExpr:y  -> (x - y)
           | mulExpr,
  mulExpr  = mulExpr:x '*' primExpr:y -> (x * y)
           | mulExpr:x '/' primExpr:y -> (x / y)
           | primExpr,
  primExpr = '(' expr:x ')'           -> x
           | number,
  expr     = addExpr
}

Calc.matchAll('6*(4+3)cc', 'expr')
 

ometa Ab {
  A   = A:x 'a' -> (x + 1) 
      | 'b'   -> 0
}


Ab.matchAll('baa6*(4+3)', 'A')


ometa exp {
  digit    = super(#digit):d          -> d.digitValue(),
  number   = number:n digit:d         -> (n * 10 + d)
           | digit,
  addExpr  = addExpr:x '-' mulExpr:y  -> (x - y)
           | mulExpr,
  mulExpr  = primExpr,
  primExpr = number,
  expr     = addExpr
}

exp.matchAll('6-2-1+555', 'expr')


ometa exp {
  digit    = super(#digit):d          -> d.digitValue(),
  number   = number:n digit:d         -> (n * 10 + d)
           | digit,
  indirect = addExpr,
  addExpr  = indirect:x '-' number:y  -> (x - y)
           | number,
  expr     = addExpr
}

exp.matchAll('8-2-1+555', 'expr')