Struct LexerBuilder

pub struct LexerBuilder<'r, K> { /* private fields */ }

Builder struct for Lexer.

Implementations

impl<'r, K> LexerBuilder<'r, K>

pub fn new() -> Self

Create a new LexerBuilder.

pub fn token(self, re: &'r str, kind: K) -> Self

Add a new token that matches the regular expression re. This uses the same syntax as the regex crate.

If the regex matches, it will return a token of kind kind.

use regex_lexer::{LexerBuilder, Token};
 
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
enum Tok {
    Num,
    // ...
}

let lexer = LexerBuilder::new()
    .token(r"[0-9]*", Tok::Num)
    .ignore(r"\s+") // skip whitespace
    // ...
    .build()?;

assert_eq!(
    lexer.tokens("1 2 3").collect::<Vec<_>>(),
    vec![
        Token { kind: Tok::Num, span: 0..1, text: "1" },
        Token { kind: Tok::Num, span: 2..3, text: "2" },
        Token { kind: Tok::Num, span: 4..5, text: "3" },
    ],
);

If multiple regexes all match, then whichever is defined last will be given priority.

use regex_lexer::{LexerBuilder, Token};
 
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
enum Tok {
    Ident,
    Let,
    // ...
}

let lexer = LexerBuilder::new()
    .token(r"[a-zA-Z_][a-zA-Z0-9_]*", Tok::Ident)
    .token(r"let\b", Tok::Let)
    // ...
    .ignore(r"\s+")
    .build()?;

assert_eq!(
    lexer.tokens("let lettuce").collect::<Vec<_>>(), 
    vec![
        Token { kind: Tok::Let, span: 0..3, text: "let" },
        Token { kind: Tok::Ident, span: 4..11, text: "lettuce" },
    ],
);

pub fn ignore(self, re: &'r str) -> Self

Add a new regex which if matched will ignore the matched text.

pub fn build(self) -> Result<Lexer<K>, Error>

Construct a Lexer which matches these tokens.

Errors

If a regex cannot be compiled, a Error is returned.

Trait Implementations

impl<'r, K> Default for LexerBuilder<'r, K>

fn default() -> Self

Returns the “default value” for a type.