Struct RuleBuilder 

pub struct RuleBuilder { /* private fields */ }

Builder for parser rules

Implementations

impl RuleBuilder

pub fn new(name: &str) -> Self

pub fn parse(&self, rule_name: &str) -> Combinator

Reference another rule by name

pub fn lit(&self, s: &str) -> Combinator

Match a literal string exactly (e.g., “if”, “===”, “+”)

pub fn char(&self, c: char) -> Combinator

Match a single specific character

pub fn digit(&self) -> Combinator

Match any decimal digit (0-9)

pub fn hex_digit(&self) -> Combinator

Match any hexadecimal digit (0-9, a-f, A-F)

pub fn alpha(&self) -> Combinator

Match any alphabetic character (a-z, A-Z)

pub fn alpha_num(&self) -> Combinator

Match any alphanumeric character (a-z, A-Z, 0-9)

pub fn ws(&self) -> Combinator

Match any whitespace character (space, tab, newline, etc.)

pub fn ident_start(&self) -> Combinator

Match identifier start character (a-z, A-Z, _, $)

pub fn ident_cont(&self) -> Combinator

Match identifier continue character (a-z, A-Z, 0-9, _, $)

pub fn any_char(&self) -> Combinator

Match any single character

pub fn range(&self, from: char, to: char) -> Combinator

Match a character in the given range (inclusive)

pub fn not_followed_by(&self, inner: Combinator) -> Combinator

Negative lookahead: succeed if inner does NOT match, consume nothing

pub fn followed_by(&self, inner: Combinator) -> Combinator

Positive lookahead: succeed if inner matches, consume nothing

pub fn capture(&self, inner: Combinator) -> Combinator

Capture the matched text as a string token

pub fn memoize(&self, id: usize, inner: Combinator) -> Combinator

Memoize the result of parsing to avoid exponential backtracking.

When a memoized combinator is tried at a position, the result is cached. If the same combinator is tried again at the same position (due to backtracking), the cached result is returned instead of re-parsing.

Use this for rules that:

1. Appear in multiple Choice alternatives
2. Contain recursion
3. Are frequently backtracked

The id parameter must be unique across all memoization points.

pub fn sequence<T: IntoCombinatorsVec>(&self, items: T) -> Combinator

Sequence of combinators

pub fn choice<T: IntoCombinatorsVec>(&self, items: T) -> Combinator

Ordered choice (first match wins, auto-backtrack)

pub fn zero_or_more(&self, inner: Combinator) -> Combinator

Zero or more

pub fn one_or_more(&self, inner: Combinator) -> Combinator

One or more

pub fn optional(&self, inner: Combinator) -> Combinator

Optional (zero or one)

pub fn skip(&self, inner: Combinator) -> Combinator

Parse but discard result

pub fn separated_by( &self, item: Combinator, separator: Combinator, ) -> Combinator

Separated list: item (sep item)*

pub fn separated_by_trailing( &self, item: Combinator, separator: Combinator, ) -> Combinator

Separated list with optional trailing separator

pub fn pratt<F>(&self, operand: Combinator, f: F) -> Combinator

where F: FnOnce(PrattBuilder) -> PrattBuilder,

Pratt expression parsing

Trait Implementations

impl Debug for RuleBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.