Struct mini_haskell::scanner::Scanner

pub struct Scanner<I> { /* fields omitted */ }

Scanner with a back buffer.

Implementations

impl<I: Read> Scanner<I>

pub fn id_or_sym(&mut self) -> Result<Lexeme>

Identifiers or operators.

impl<I: Read> Scanner<I>

pub fn whitespace(&mut self) -> Result<()>

Haskell 2010 Report (2.2.whitespace)

impl<I: Read> Scanner<I>

pub fn numeric_literal(&mut self) -> Result<Lexeme>

Numeric literals: integers or floats.

impl<I: Read> Scanner<I>

pub fn char_or_string(&mut self) -> Result<Lexeme>

Character literals or string literals.

impl<I: Read> Scanner<I>

pub fn special(&mut self) -> Result<Lexeme>

Special: delimiters.

impl<I: Read> Scanner<I>

pub fn expected<T>(&mut self, t: LexemeType) -> Result<T>

Fail fast with t as the expected lexeme type.

pub fn keep_trying<T>() -> Result<T>

Fail for future recovery from alt!.

pub fn err_expected(&mut self, t: LexemeType) -> LexError

Create a LexError with the expected lexeme type.

impl<I> Scanner<I>

pub fn new(input: I) -> Self

Create a new scanner from the back buffer.

pub fn anchored<R: Either>(&mut self, f: impl FnOnce(&mut Scanner<I>) -> R) -> R

Set an anchor for possible revert in future. Use an Either for error indication.

pub fn many<ET: Either<Left = E>, EU: Either<Left = E>, E>(
    &mut self,
    f: impl FnMut(&mut Scanner<I>) -> ET,
    init: EU::Right,
    join: impl FnMut(&mut EU::Right, ET::Right)
) -> EU

Match many of this rule.

pub fn many_<ET: Either<Left = E>, ER: Either<Left = E>, E>(
    &mut self,
    f: impl FnMut(&mut Scanner<I>) -> ET
) -> ER where
    ER::Right: From<()>, 

Match many of this rule, ignore the results.

pub fn some<ET: Either<Left = E>, EU: Either<Left = E>, E>(
    &mut self,
    f: impl FnMut(&mut Scanner<I>) -> ET,
    init: EU::Right,
    join: impl FnMut(&mut EU::Right, ET::Right)
) -> EU

Match many of this rule.

pub fn some_<ET: Either<Left = E>, ER: Either<Left = E>, E>(
    &mut self,
    f: impl FnMut(&mut Scanner<I>) -> ET
) -> ER where
    ER::Right: From<()>, 

Match many of this rule, ignore the results.

pub fn sep_by<ET: Either<Left = E>, EU: Either<Left = E>, ER: Either<Left = E>, E>(
    &mut self,
    f: impl FnMut(&mut Scanner<I>) -> ET,
    g: impl FnMut(&mut Scanner<I>) -> ER,
    init: EU::Right,
    join: impl FnMut(&mut EU::Right, ET::Right)
) -> EU

Match many of this rule separated by some other rule.

pub fn sep_by_<ET, EU, ER, E>(
    &mut self,
    f: impl FnMut(&mut Scanner<I>) -> ET,
    g: impl FnMut(&mut Scanner<I>) -> ER
) -> EU where
    ET: Either<Left = E>,
    ER: Either<Left = E>,
    EU: Either<Left = E>,
    EU::Right: From<()>, 

Match many of this rule separated by some other rule, ignore the results.

pub fn end_by<ET: Either<Left = E>, EU: Either<Left = E>, ER: Either<Left = E>, E>(
    &mut self,
    f: impl FnMut(&mut Scanner<I>) -> ET,
    g: impl FnMut(&mut Scanner<I>) -> ER,
    init: EU::Right,
    join: impl FnMut(&mut EU::Right, ET::Right)
) -> EU

Match many of this rule ended by some other rule.

impl<I: Read> Scanner<I>

pub fn next_lexeme(&mut self) -> Result<Lexeme>

Get the next lexeme from the Scanner.

Trait Implementations

impl<I: Read> From<Scanner<I>> for RawLexemeIterator<I>

fn from(scanner: Scanner<I>) -> Self

Performs the conversion.

impl<I: Read> Stream for Scanner<I>

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

Peek the next character without consuming it.

fn next(&mut self) -> Option<char>

Take the next character and consume it.

fn match<'a>(&mut self, s: &'a str) -> Option<&'a str>

Match a string against the input.

fn span<T>(
    &mut self,
    f: impl FnMut(char) -> bool,
    init: T,
    join: impl FnMut(&mut T, char)
) -> T

Pop many characters until the predicate fails.

fn span_collect(&mut self, f: impl FnMut(char) -> bool) -> Vec<char>

Pop many characters until the predicate fails, collect them into a Vec.

fn span_collect_string(&mut self, f: impl FnMut(char) -> bool) -> String

Pop many characters until the predicate fails, collect them into a String.

fn span_(&mut self, f: impl FnMut(char) -> bool)

Pop many characters until the predicate fails, ignore the characters.