Struct Parser 

pub struct Parser<'t> {
    pub lexer: Lexer<'t>,
    pub next_tok: Option<PResult<Token>>,
    pub last_loc: Span,
    pub elide_do: bool,
}

Handles stateful extraction from a Lexer, with single-[Token] lookahead.

Fields

lexer: Lexer<'t>

A stream of tokens produced from some source text

next_tok: Option<PResult<Token>>

The currently-peeked output from the Lexer

last_loc: Span

The span of the last-consumed [Token]

elide_do: bool

Whether the last-consumed [Token] can stand in for a semicolon in a do sequence

Implementations

impl<'t> Parser<'t>

pub fn new(lexer: Lexer<'t>) -> Self

Constructs a new Parser

pub const fn then<T>(&self, t: T) -> T

The identity function. This exists to make production chaining easier.

pub const fn span(&self) -> Span

Gets the [struct@Span] of the last-consumed [Token]

pub fn parse<T: Parse<'t>>(&mut self, level: T::Prec) -> PResult<T>

Parses a value that implements the Parse trait.

pub fn parse_entire<T: Parse<'t>>(&mut self, level: T::Prec) -> PResult<T>

Parses a value that implements the Parse trait, and asserts the entire input has been consumed.

pub fn peek(&mut self) -> PResult<&Token>

Peeks the next [Token]. Returns ParseError::FromLexer on lexer error.

pub fn peek_if(&mut self, expected: TKind) -> PResult<Option<&Token>>

Peeks the next token if it matches the expected [TKind]

pub fn take(&mut self) -> PResult<Token>

Consumes and returns the currently-peeked [Token].

pub fn take_lexeme(&mut self) -> PResult<Lexeme>

Consumes the currently-peeked [Token], returning its lexeme without cloning.

pub fn next(&mut self) -> PResult<Token>

pub fn next_if(&mut self, expected: TKind) -> PResult<Result<Token, TKind>>

Consumes and returns the next [Token] if it matches the expected [TKind]

pub fn list<P: Parse<'t>>( &mut self, elems: Vec<P>, level: P::Prec, sep: TKind, end: TKind, ) -> PResult<Vec<P>>

Parses a list of P separated by sep tokens, ending in an end token.

List<T> = (T sep)* T? end ;

pub fn list_bare<P: Parse<'t>>( &mut self, elems: Vec<P>, level: P::Prec, sep: TKind, ) -> PResult<Vec<P>>

Parses a list of one or more P at level level, separated by sep tokens

UnterminatedList<P> = P (sep P)*

pub fn opt_if<P: Parse<'t>>( &mut self, level: P::Prec, next: TKind, ) -> PResult<Option<P>>

Parses into an Option<P> if the next token is next

pub fn opt<P: Parse<'t>>( &mut self, level: P::Prec, end: TKind, ) -> PResult<Option<P>>

Parses a P unless the next [Token]’s [TKind] is end

pub fn expect(&mut self, next: TKind) -> PResult<&mut Self>

Ensures the next [Token]’s [TKind] is next

pub fn consume(&mut self) -> &mut Self

Consumes the currently peeked token without returning it.

pub fn split(&mut self) -> PResult<Token>

Consumes the next token, and attempts to split it into multiple.

If the next token cannot be split, it will be returned.

Trait Implementations

impl<'t> Debug for Parser<'t>

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

Formats the value using the given formatter.