Enum Expression 

pub enum Expression<M> {
    Star(M, Box<Expression<M>>),
    Plus(M, Box<Expression<M>>),
    Maybe(M, Box<Expression<M>>),
    RepeatExact(M, Box<Expression<M>>, Number<M>),
    RepeatRange(M, Box<Expression<M>>, Number<M>, Number<M>),
    RepeatLower(M, Box<Expression<M>>, Number<M>),
    Delimited(M, Box<Expression<M>>, Box<Expression<M>>, DelimitedBound<M>, bool),
    Literal(M, String<M>),
    Paren(M, Vec<Box<Expression<M>>>),
    Labelled(M, Identifier<M>, Box<Expression<M>>),
    Sort(M, Identifier<M>),
    Class(M, CharacterClass<M>),
}

With expressions, you can give the syntax rules of a single constructor. Expressions can be nested and combined.

Variants

Star(M, Box<Expression<M>>)

Repeat some expression zero or more times Equivalent to <expression> {0,}

Plus(M, Box<Expression<M>>)

Repeat some expression one or more times Equivalent to <expression> {1,}

Maybe(M, Box<Expression<M>>)

Optionally have some expression. Equivalent to <expression> {0,1}

RepeatExact(M, Box<Expression<M>>, Number<M>)

Exact repetition. The expression is repeated an exact number of times. Equivalent to ranged repetition with an equal lower and upper bound.

RepeatRange(M, Box<Expression<M>>, Number<M>, Number<M>)

Ranged repetition. The expression may be repeated any number of times, within the range. Both bounds are inclusive.

RepeatLower(M, Box<Expression<M>>, Number<M>)

Ranged repetition, without upper bound (or an infinite maximum)

Delimited(M, Box<Expression<M>>, Box<Expression<M>>, DelimitedBound<M>, bool)

Delimited expressions. Says that some expression should be repeatedly parsed, but between two parses, a delimiter should be parsed too. For example, comma seperated expressions. The final trailing keyword enables a trailing separator after the sequence. If not present, no trailing separator is allowed.

Literal(M, String<M>)

Matches a piece of text exactly. Layout is parsed within a literal.

Paren(M, Vec<Box<Expression<M>>>)

You can use parentheses to group parts of expressions.

Labelled(M, Identifier<M>, Box<Expression<M>>)

Sort(M, Identifier<M>)

Reference another sort within this expression. That sort should be parsed in this position in the expression.

Class(M, CharacterClass<M>)

A character class (range of characters) should be parsed here.

Trait Implementations

impl<M: AstInfo> AstNode<M> for Expression<M>

fn ast_info(&self) -> &M

fn constructor(&self) -> &'static str

fn sort(&self) -> &'static str

fn as_str<'a>(&'a self) -> &'a str

where M: SpannedAstInfo + 'a,

fn traverse<F>(&self, _f: F)

where Self: Sized, F: FnMut(&dyn AstNode<M>),

impl<M: Debug> Debug for Expression<M>

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

Formats the value using the given formatter.

impl<'de, M> Deserialize<'de> for Expression<M>

where M: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<M: AstInfo> FromPairs<M> for Expression<M>

fn from_pairs<G: GenerateAstInfo<Result = M>>( pair: &ParsePairSort<'_>, generator: &mut G, ) -> Self

impl<M: PartialEq> PartialEq for Expression<M>

fn eq(&self, other: &Expression<M>) -> 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<M> Serialize for Expression<M>

where M: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<M> StructuralPartialEq for Expression<M>