Idea

A rust macro for generating PEG parsers.

Features

• Literals
  • strs "Hello"
  • chars 'c'
  • char ranges '0'..='9'
• Span $e
• Atomic @e
• Named name: e
• Lookahead
  • Positive lookahead &e
  • Negative lookahead !e
• Sequence e e
• Alternation e | e
• Number
  • Many 0 (zero or more) e*
  • Many 1 (one or more) e+
  • Optional (zero or one) e?

Predefined rules

any = // Matches any single character digit = '0'..='9' alpha = insensitive['a'..='z'] alnum = alpha | digit comment = !any space = (whitespace | comment)*

Grammar

rule = name '=' alt alt = cat ('|' cat)* action? cat = (named | unary)+ named = name ':' unary unary = prefix | postfix | atom prefix_op = '$' // Span | '@' // Atomic | '!' // Negative lookahead | '&' // Positive lookahead postfix_op = '*' // Many0 | '+' // Many1 | '?' // Optional prefix = prefix_op atom postfix = postfix_op atom atom = name | literal | parenthesized parenthesized = '(' alt ')'

Left-Recursion

Detection

Runtime

Try the rule over and over, with recursion depth from 1.., until the parse fails. Now the latest cached result is the answer.

Compilation

• Parse the syntax
• Replace all rule names with indices
• Detect overwriting of built-in rules
• Mark left-recursive rules
• Report refutable bindings

Delim

For delimiters, we may want to select for - 0 or more occurrences [] - 1 or more occurrences [1] - 1 or more occurrences, but only when there is a trailing comma [1,] - When x has return type X and y has return type Y, x ^ y should have return type (Vec<X>, Vec<Y>) - Tuple can be made as follows:

tuple = '(' item: item ',' items: item ^ ',' ')' { let mut items = items.0; items.insert(0, item); items }

Alternatively (this isn't possible yet)

tuple = '(' items: item ^ ',' ')' {? // At least one comma match items.1.len() { 0 => None _ => Some(items.0) } }

Todo