Struct Pattern 

pub struct Pattern {
    pub pattern: String,
    pub terminal_type: TerminalID,
    pub priority: usize,
    pub lookahead: Lookahead,
}

A pattern is a data structure that is used during the construction of the NFA.

Fields

pattern: String

The pattern string that is used to match input tokens.

terminal_type: TerminalID

The terminal type associated with the pattern.

priority: usize

The priority of the pattern, used to resolve conflicts between patterns. Patterns with priority lower value are preferred over those with higher priority value.

lookahead: Lookahead

The lookahead constraint for the pattern, which can be positive, negative, or none.

Implementations

impl Pattern

pub fn new(pattern: String, terminal_type: TerminalID) -> Self

Creates a new pattern with the given pattern string, terminal type, and optional lookahead.

Arguments

• pattern - The pattern string.
• terminal_type - The terminal type associated with the pattern.

pub fn with_lookahead(self, lookahead: Lookahead) -> Self

Sets the lookahead constraint for the pattern while consuming the current pattern.

Arguments

• lookahead - The lookahead constraint to set.

pub fn with_priority(self, priority: usize) -> Self

Sets the priority of the pattern.

Arguments

• priority - The priority to set.

Trait Implementations

impl Clone for Pattern

fn clone(&self) -> Pattern

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Pattern

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

Formats the value using the given formatter.

impl Default for Pattern

fn default() -> Pattern

Returns the “default value” for a type.

impl Eq for Pattern

impl Parse for Pattern

This is used to create a pattern from a part of a macro input. The macro input looks like this:

token r"World" followed by r"!" => 11;

where the lookahead part can be either

followed by r"!";
```text
or
```text
not followed by r"!";
```text
or it can be omitted completely.

The lookahead part should be parsed with the help of the `Lookahead` struct's `parse` method.

Note that the `token` keyword is not part of the pattern, but it is used to identify the
pattern.

fn parse(input: ParseStream<'_>) -> Result<Self>

impl PartialEq for Pattern

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Pattern