Struct Rules 

pub struct Rules {
    pub symbols: Vec<char>,
    pub region_tree: Region,
    pub escape_symbol: char,
    pub compounds: Vec<(char, char)>,
}

Determine lexing rules for the parser

Rules struct that contains list of symbols as well as region tree

This struct requires two things:

1. List of symbols
2. Region Tree

More on those below in the Fields section

Example

let symbols = vec!['+', '-', '*', '/', '(', ')', '&', '|', '!'];
let compounds = vec![('&', '&'), ('|', '|')];
let region = reg![
    reg!(str as "string literal" => {
        begin: "'",
        end: "'"
    })
];
Rules::new(symbols, compounds, region);

Fields

symbols: Vec<char>

Symbols that should be separated (most commonly: (, ), +, -, …) This handles situations like for instance if we want to parse 1+1 as three tokens 1 + 1 and not single 1+1 token.

region_tree: Region

Region tree that determines what code regions should remain untokenized. Most common case is a string where we want to preserve all the spaces and words inside.

escape_symbol: char

Escape symbol

compounds: Vec<(char, char)>

Vector of pairs of symbols that should be merged together

Implementations

impl Rules

pub fn new( symbols: Vec<char>, compounds: Vec<(char, char)>, region_tree: Region, ) -> Rules

Creates new rules that can be supplied to the compiler

pub fn set_escape(self, symbol: char) -> Self

Set custom escape symbol for your language

Trait Implementations

impl Clone for Rules

fn clone(&self) -> Rules

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rules

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

Formats the value using the given formatter.

impl PartialEq for Rules

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