Enum Node 

#[non_exhaustive]
pub enum Node {
    Dot,
    LineAssertion,
    PerlClass,
    EscapedLiteral,
    EscapedChar {
        meta: bool,
    },
    StdAssertion,
    UncountedRepetition,
    CountedRepetition(CountedRepetition),
    HexEscape,
    Alteration,
    GroupStart {
        name: Option<GroupName>,
        flags: Option<Span>,
    },
    GroupEnd,
    SetStart {
        negation: Option<Span>,
    },
    SetEnd,
    SetOp,
    SetRange,
    AsciiClass,
    Comment,
}

Syntax node of a regular expression.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Dot

Any char: .

LineAssertion

Zero-length line assertion: ^, $.

PerlClass

Perl character class: \d, \s, \w etc.

EscapedLiteral

Escaped literal with special meaning, such as \n or \t.

EscapedChar

Escaped char without special meaning, such as \*.

Fields

meta: bool

Must the char be escaped?

StdAssertion

Standard assertion like \A (beginning of the haystack) or \< (start-of-word boundary).

UncountedRepetition

Uncounted repetition, like *, + or ?, with an optional non-greedy marker.

CountedRepetition(CountedRepetition)

Counted repetition, like {3} or {3,5}, with an optional non-greedy marker.

HexEscape

Hexadecimal escape, like \x0C or \u{123}.

Alteration

Alteration char (|).

GroupStart

Group start ( together with optional flags and naming.

Fields

name: Option<GroupName>

Group name.

flags: Option<Span>

Flags for the current group, e.g. ?x-m in (?x-m) or in (?x-m:.*). By design, this is mutually exclusive with name.

GroupEnd

Group end ).

SetStart

Set start [.

Fields

negation: Option<Span>

Negation ^.

SetEnd

Set end ].

SetOp

Set operation: &&, -- or ~~.

SetRange

Set range char: -.

AsciiClass

ASCII char class, e.g., [:alnum:].

Comment

Comment, e.g., # Test. May span over multiple lines, where comments may be preceded by whitespace (but no AST nodes).

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 Copy for Node

impl StructuralPartialEq for Node