Enum lwb_parser::parser::syntax_file::ast::Expression

pub enum Expression<M: AstInfo> {
    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>),
    Literal(M, Vec<StringChar<M>>),
    SingleQuoteLiteral(M, Vec<StringChar<M>>),
    Delimited(M, Box<Expression<M>>, Box<Expression<M>>, DelimitedBound<M>, bool),
    Sort(M, Identifier<M>),
    Class(M, CharacterClass<M>),
    Paren(M, Vec<Box<Expression<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)

Literal(M, Vec<StringChar<M>>)

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

SingleQuoteLiteral(M, Vec<StringChar<M>>)

Also a literal, see [literal]

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.

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.

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

You can use parentheses to group parts of expressions.

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 traverse<F>(&self, _f: F) where
    Self: Sized,
    F: FnMut(&dyn AstNode<M>), 

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

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

Formats the value using the given formatter.

impl<'de, M: AstInfo> 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: AstInfo> 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.