Enum Combinator 

pub enum Combinator {
    Rule(String),
    Sequence(Vec<Combinator>),
    Choice(Vec<Combinator>),
    ZeroOrMore(Box<Combinator>),
    OneOrMore(Box<Combinator>),
    Optional(Box<Combinator>),
    Skip(Box<Combinator>),
    SeparatedBy {
        item: Box<Combinator>,
        separator: Box<Combinator>,
        trailing: bool,
    },
    Pratt(PrattDef),
    Mapped {
        inner: Box<Combinator>,
        mapping: String,
    },
    Literal(String),
    Char(char),
    CharClass(CharClass),
    CharRange(char, char),
    AnyChar,
    NotFollowedBy(Box<Combinator>),
    FollowedBy(Box<Combinator>),
    Capture(Box<Combinator>),
    Memoize {
        id: usize,
        inner: Box<Combinator>,
    },
}

Parser combinators for scannerless parsing

Variants

Rule(String)

Reference another rule by name

Sequence(Vec<Combinator>)

Sequence of combinators

Choice(Vec<Combinator>)

Ordered choice (first match wins, auto-backtrack)

ZeroOrMore(Box<Combinator>)

Zero or more

OneOrMore(Box<Combinator>)

One or more

Optional(Box<Combinator>)

Optional (zero or one)

Skip(Box<Combinator>)

Parse but discard result

SeparatedBy

Separated list: item (sep item)*

Fields

item: Box<Combinator>

separator: Box<Combinator>

trailing: bool

Pratt(PrattDef)

Pratt expression parsing

Mapped

AST mapping applied to inner combinator

Fields

inner: Box<Combinator>

mapping: String

Literal(String)

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

Char(char)

Match a single character

CharClass(CharClass)

Match a character class (digit, alpha, etc.)

CharRange(char, char)

Match a character range (e.g., ‘a’..=‘z’)

AnyChar

Match any single character

NotFollowedBy(Box<Combinator>)

Negative lookahead (match if inner does NOT match, consume nothing)

FollowedBy(Box<Combinator>)

Positive lookahead (match if inner matches, consume nothing)

Capture(Box<Combinator>)

Capture the matched text as a string

Memoize

Memoize the result of parsing at each position to avoid exponential backtracking

Fields

id: usize

Unique identifier for this memoization point

inner: Box<Combinator>

The inner combinator to memoize

Trait Implementations

impl Clone for Combinator

fn clone(&self) -> Combinator

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CombinatorExt for Combinator

fn ast(self, mapping: TokenStream) -> Combinator

Apply AST mapping to this combinator

impl Debug for Combinator

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

Formats the value using the given formatter.

impl From<&str> for Combinator

Allow string literals to be used as Combinator::Literal

fn from(s: &str) -> Self

Converts to this type from the input type.