Enum Node

pub enum Node {
    Alternation(Vec<Node>),
    Assertion(AssertionKind),
    Class(ClassKind),
    Concat(Vec<Node>),
    Dot,
    Empty,
    Literal(Literal),
    Char(LiteralChar),
    Group(Box<Node>),
    Repetition {
        node: Box<Node>,
        kind: RepetitionKind,
        greedy: bool,
    },
}

AST node of a regular expression.

Variants

Alternation(Vec<Node>)

Alternation of nodes, ie node|node|....

Assertion(AssertionKind)

Zero-width assertion, e.g. ^, \b, …

Class(ClassKind)

Set of allowed values for a single byte.

Concat(Vec<Node>)

Concatenation, must match in order.

Dot

The special . character.

Empty

Empty expression.

Literal(Literal)

Literal byte.

Char(LiteralChar)

Literal char, not ascii.

Group(Box<Node>)

A group, i.e. (…).

Repetition

Repetition of an expression.

Fields

node: Box<Node>

Expression to repeat.

kind: RepetitionKind

Kind of repetition.

greedy: bool

Is the repetition greedy or not.

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl PartialEq for Node

fn eq(&self, other: &Node) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Node

impl StructuralPartialEq for Node