Struct BufferedInput

pub struct BufferedInput<'a> { /* private fields */ }

Implementations

impl<'a> BufferedInput<'a>

pub fn take_buffer(&mut self) -> String

Copy out the buffer and clear it

pub fn peek(&mut self) -> Option<char>

Peek at the next character

pub fn skip(&mut self) -> Option<char>

Get the next character but don’t push it to the buffer

pub fn skip_if<P: Fn(&char) -> bool>(&mut self, predicate: P) -> Option<char>

Skip if the given predicate is true

pub fn skip_while<P: Fn(&char) -> bool>(&mut self, predicate: P)

Skip while the given predicate is true

pub fn accept(&mut self) -> Option<char>

Retrieve the next character and increment the input position

pub fn accept_if<P: Fn(&char) -> bool>(&mut self, predicate: P) -> Option<char>

Call self.next() if the peeked character is identical to b

Examples found in repository

examples/calc.rs (line 12)

fn lex_int(input: &mut BufferedInput) -> TokenKind {
    input.accept_while(char::is_ascii_digit);
    if let Some(_) = input.accept_if(|c| *c == '.') {
        return lex_float(input);
    }
    TokenKind::Int
}

pub fn accept_while<P: Fn(&char) -> bool>(&mut self, predicate: P)

Call self.next() while the peeked character fulfils predicate

Examples found in repository

examples/calc.rs (line 11)

fn lex_int(input: &mut BufferedInput) -> TokenKind {
    input.accept_while(char::is_ascii_digit);
    if let Some(_) = input.accept_if(|c| *c == '.') {
        return lex_float(input);
    }
    TokenKind::Int
}

fn lex_float(input: &mut BufferedInput) -> TokenKind {
    input.accept_while(char::is_ascii_digit);
    TokenKind::Float
}

fn lex_name(input: &mut BufferedInput) -> TokenKind {
    input.accept_while(|c| *c == '_' || c.is_ascii_alphabetic());
    TokenKind::Name
}

pub fn accept_or<P: Fn(&char) -> bool, T>( &mut self, predicate: P, ok: T, default: T, ) -> T

Accept the given byte and return ok, or else return default

This is useful for matching multi-character tokens:

match c {
    '=' => input.accept_or(|&c| c == '=', TokenKind::DoubleEquals, TokenKind::Equals),
    _ => {},
}

pub fn skip_whitespace(&mut self)

Skip whitespace, preserving the original buffer before any whitespace was encountered