Enum GrammarExpr 

pub enum GrammarExpr {
    Empty,
    Terminal(String),
    TerminalInsensitive(String),
    CharRange(char, char),
    CharClass {
        negated: bool,
        items: Vec<CharClassItem>,
    },
    AnyChar,
    NonTerminal(String),
    Choice {
        ordered: bool,
        alternatives: Vec<Self>,
    },
    Sequence(Vec<Self>),
    Optional(Box<Self>),
    ZeroOrMore(Box<Self>),
    OneOrMore(Box<Self>),
    Repeat {
        expr: Box<Self>,
        min: usize,
        max: Option<usize>,
    },
    And(Box<Self>),
    Not(Box<Self>),
    Capture {
        label: Option<String>,
        expr: Box<Self>,
    },
}

One node of the grammar expression algebra.

Variants

Empty

Matches the empty string.

Terminal(String)

Literal string terminal, for example "fn".

TerminalInsensitive(String)

Case-insensitive literal string terminal.

CharRange(char, char)

Inclusive character range, for example 'a'..='z'.

CharClass

Explicit set of characters or ranges.

Fields

negated: bool

Whether the class is negated.

items: Vec<CharClassItem>

Characters and ranges accepted by the class.

AnyChar

The any-character wildcard.

NonTerminal(String)

Reference to another grammar rule by name.

Choice

Alternation between expressions.

Fields

ordered: bool

Whether alternatives are ordered, as in PEG choice.

alternatives: Vec<Self>

Alternative expressions.

Sequence(Vec<Self>)

Concatenation of expressions.

Optional(Box<Self>)

Optional expression.

ZeroOrMore(Box<Self>)

Zero-or-more repetition.

OneOrMore(Box<Self>)

One-or-more repetition.

Repeat

Counted repetition.

Fields

expr: Box<Self>

Repeated expression.

min: usize

Minimum number of repetitions.

max: Option<usize>

Maximum number of repetitions, or None for unbounded.

And(Box<Self>)

Positive lookahead predicate.

Not(Box<Self>)

Negative lookahead predicate.

Capture

Labelled or anonymous capture.

Fields

label: Option<String>

Optional capture label.

expr: Box<Self>

Captured expression.

Implementations

impl GrammarExpr

pub const fn empty() -> Self

Builds an empty-string expression.

pub fn terminal(value: impl Into<String>) -> Self

Builds a literal terminal expression.

pub fn terminal_insensitive(value: impl Into<String>) -> Self

Builds a case-insensitive literal terminal expression.

pub const fn char_range(start: char, end: char) -> Self

Builds an inclusive character range expression.

pub fn char_class<I>(negated: bool, items: I) -> Self

where I: IntoIterator<Item = CharClassItem>,

Builds a character class expression.

pub const fn any_char() -> Self

Builds an any-character wildcard expression.

pub fn non_terminal(value: impl Into<String>) -> Self

Builds a non-terminal reference expression.

pub fn choice<I>(ordered: bool, alternatives: I) -> Self

where I: IntoIterator<Item = Self>,

Builds a choice expression.

pub fn sequence<I>(items: I) -> Self

where I: IntoIterator<Item = Self>,

Builds a sequence expression.

pub fn optional(expr: Self) -> Self

Builds an optional expression.

pub fn zero_or_more(expr: Self) -> Self

Builds a zero-or-more repetition expression.

pub fn one_or_more(expr: Self) -> Self

Builds a one-or-more repetition expression.

pub fn repeat(expr: Self, min: usize, max: Option<usize>) -> Self

Builds a counted repetition expression.

pub fn and(expr: Self) -> Self

Builds a positive lookahead expression.

pub fn not(expr: Self) -> Self

Builds a negative lookahead expression.

pub fn capture(label: impl Into<String>, expr: Self) -> Self

Builds a labelled capture expression.

pub fn capture_unlabeled(expr: Self) -> Self

Builds an anonymous capture expression.

Trait Implementations

impl Clone for GrammarExpr

fn clone(&self) -> GrammarExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GrammarExpr

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

Formats the value using the given formatter.

impl Display for GrammarExpr

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

Formats the value using the given formatter.

impl PartialEq for GrammarExpr

fn eq(&self, other: &GrammarExpr) -> 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 GrammarExpr

impl StructuralPartialEq for GrammarExpr