Struct Grammar 

pub struct Grammar {
    pub rules: Vec<RuleDef>,
    pub ast_config: AstConfig,
}

Main grammar builder

Fields

rules: Vec<RuleDef>

ast_config: AstConfig

Implementations

impl Grammar

pub fn new() -> Self

pub fn ast_config<F>(self, f: F) -> Self

where F: FnOnce(AstConfigBuilder) -> AstConfigBuilder,

Configure AST integration settings

pub fn rule<F>(self, name: &str, f: F) -> Self

where F: FnOnce(&RuleBuilder) -> Combinator,

Define a parser rule

pub fn build(self) -> CompiledGrammar

Finalize and validate the grammar

pub fn build_optimized(self) -> CompiledGrammar

Build with automatic backtracking optimization

This is equivalent to calling .build().optimize_backtracking(). It detects Choice nodes with shared prefixes containing recursive rules and rewrites them to factor out the common prefix.

pub fn build_with_memoization(self) -> CompiledGrammar

Build with automatic memoization to avoid exponential backtracking.

This analyzes the grammar to identify rules that would benefit from memoization and automatically wraps them. Use this when you have patterns that cause exponential backtracking (like TypeScript’s identifier<types>(args) vs comparison operators).

The process:

1. Analyze the grammar to find Choice nodes with shared recursive prefixes
2. Identify rule references in those prefixes
3. Wrap those rules with memoization
4. Build the grammar

pub fn build_optimized_with_memoization(self) -> CompiledGrammar

Build with both prefix factoring optimization and automatic memoization.

This combines the benefits of both optimization strategies:

1. Prefix factoring rewrites Choice nodes to factor out common prefixes
2. Memoization caches results for rules that cause exponential backtracking

Use this for the most comprehensive backtracking prevention.

Trait Implementations

impl Debug for Grammar

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

Formats the value using the given formatter.

impl Default for Grammar

fn default() -> Grammar

Returns the “default value” for a type.