Struct PrattParser 

pub struct PrattParser<L: Language, T: Pratt<L>> { /* private fields */ }

A Pratt parser implementation.

Examples

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum Token { Number, Plus, Minus, Star, Slash, Eof }
impl TokenType for Token {
    const END_OF_STREAM: Self = Token::Eof;
    type Role = UniversalTokenRole;
    fn role(&self) -> Self::Role { UniversalTokenRole::None }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum Element { Expr, Number, Plus, Minus, Star, Slash }
impl ElementType for Element {
    type Role = UniversalElementRole;
    fn role(&self) -> Self::Role { UniversalElementRole::None }
}
impl From<Token> for Element {
    fn from(t: Token) -> Self {
        match t {
            Token::Number => Element::Number,
            Token::Plus => Element::Plus,
            Token::Minus => Element::Minus,
            Token::Star => Element::Star,
            Token::Slash => Element::Slash,
            Token::Eof => unreachable!(),
        }
    }
}

#[derive(Clone, Copy)]
struct Lang;
impl Language for Lang {
    const NAME: &'static str = "test";
    type TokenType = Token;
    type ElementType = Element;
    type TypedRoot = ();
}

struct ExprParser;
impl Pratt<Lang> for ExprParser {
    fn primary<'a, S: oak_core::Source + ?Sized>(&self, state: &mut ParserState<'a, Lang, S>) -> &'a oak_core::GreenNode<'a, Lang> {
        let cp = state.checkpoint();
        state.bump(); // bump number
        state.finish_at(cp, Element::Number)
    }

    fn infix<'a, S: oak_core::Source + ?Sized>(&self, state: &mut ParserState<'a, Lang, S>, left: &'a oak_core::GreenNode<'a, Lang>, min_prec: u8) -> Option<&'a oak_core::GreenNode<'a, Lang>> {
        let kind = state.peek_kind()?;
        let (prec, assoc) = match kind {
            Token::Plus | Token::Minus => (1, oak_core::Associativity::Left),
            Token::Star | Token::Slash => (2, oak_core::Associativity::Left),
            _ => return None,
        }
        if prec < min_prec { return None }
        Some(binary(state, left, kind, prec, assoc, Element::Expr, |s, p| self.parse_expr(s, p)))
    }
}

impl ExprParser {
    fn parse_expr<'a, S: oak_core::Source + ?Sized>(&self, state: &mut ParserState<'a, Lang, S>, min_prec: u8) -> &'a oak_core::GreenNode<'a, Lang> {
        PrattParser::new(ExprParser).parse_expr(state, min_prec)
    }
}

Implementations

impl<L: Language, T: Pratt<L>> PrattParser<L, T>

pub const fn new(spec: T) -> Self

Creates a new Pratt parser with the given specification.

pub fn parse_expr<'a, S: Source + ?Sized>( &self, state: &mut ParserState<'a, L, S>, min_precedence: u8, ) -> &'a GreenNode<'a, L>

Parses an expression with the given minimum precedence.

pub fn parse<'a, S: Source + ?Sized>( state: &mut ParserState<'a, L, S>, min_precedence: u8, spec: &T, ) -> &'a GreenNode<'a, L>

Static version of parse_expr that takes a specification reference.