Enum IrNode 

pub enum IrNode<S, E> {
    Symbol(S),
    Any,
    Concat(Vec<Self>),
    Alternation(Vec<Self>),
    Repeat {
        node: Box<Self>,
        bounds: RepeatBounds,
        greedy: bool,
    },
    Group(Box<Self>),
    Capture {
        id: CaptureId,
        node: Box<Self>,
    },
    Anchor(Anchor),
    Assertion(AssertionId),
    Extension(E),
}

One structured pattern expression.

Variants

Symbol(S)

Match one exact symbol.

Any

Match any one symbol.

Concat(Vec<Self>)

Match every child in order.

Alternation(Vec<Self>)

Try each child as an alternative.

Repeat

Repeat a child within validated bounds.

Fields

node: Box<Self>

Expression being repeated.

bounds: RepeatBounds

Validated repetition bounds.

greedy: bool

Whether longer matches are preferred.

Group(Box<Self>)

Preserve explicit grouping from the source dialect.

Capture

Record the child’s subject span under a stable tag.

Fields

id: CaptureId

Unique capture tag within the IR.

node: Box<Self>

Captured expression.

Anchor(Anchor)

Test a zero-width subject boundary.

Assertion(AssertionId)

Evaluate a separately declared zero-width assertion.

Extension(E)

A dialect-specific operation explicitly admitted by the target engine.

Trait Implementations

impl<S: Clone, E: Clone> Clone for IrNode<S, E>

fn clone(&self) -> IrNode<S, E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug, E: Debug> Debug for IrNode<S, E>

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

Formats the value using the given formatter.

impl<S: Eq, E: Eq> Eq for IrNode<S, E>

impl<S: PartialEq, E: PartialEq> PartialEq for IrNode<S, E>

fn eq(&self, other: &IrNode<S, E>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<S: PartialEq, E: PartialEq> StructuralPartialEq for IrNode<S, E>