Struct flexi_parse::Lookahead

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

A type for peeking at the next token, and generating a helpful error if it isn’t an expected type.

Implementations

impl<'a> Lookahead<'a>

pub fn peek<T: Peek>(&self, token: T) -> bool

Returns true if the next token is the given type.

Panics

Panics if another thread panicked while peeking through this value.

Examples found in repository

examples/calc.rs (line 83)

fn primary(input: ParseStream) -> Result<Expr> {
    let lookahead = input.lookahead();
    if lookahead.peek(token::LitFloat) {
        Ok(Expr::Num(input.parse::<token::LitFloat>()?.value()))
    } else if lookahead.peek(token::LitInt) {
        Ok(Expr::Num(input.parse::<token::LitInt>()?.value() as f64))
    } else if lookahead.peek(token::LeftParen) {
        let group: Group<Parentheses> = input.parse()?;
        parse(group.into_token_stream())
    } else {
        Err(lookahead.error())
    }
}

examples/lox/main.rs (line 380)

    fn primary(input: ParseStream) -> Result<Self> {
        let lookahead = input.lookahead();
        if lookahead.peek(kw::kw_false) {
            Ok(Expr::Literal(Literal::False(input.parse()?)))
        } else if lookahead.peek(kw::kw_true) {
            Ok(Expr::Literal(Literal::True(input.parse()?)))
        } else if lookahead.peek(kw::nil) {
            Ok(Expr::Literal(Literal::Nil(input.parse()?)))
        } else if lookahead.peek(LitFloat) {
            Ok(Expr::Literal(Literal::Float(input.parse()?)))
        } else if lookahead.peek(LitInt) {
            Ok(Expr::Literal(Literal::Int(input.parse()?)))
        } else if lookahead.peek(LitStr) {
            Ok(Expr::Literal(Literal::String(input.parse()?)))
        } else if input.peek(kw::kw_super) {
            Ok(Expr::Super {
                keyword: input.parse()?,
                distance: Cell::new(None),
                dot: input.parse()?,
                method: kw::ident(input)?,
            })
        } else if input.peek(kw::this) {
            Ok(Expr::This {
                keyword: input.parse()?,
                distance: Cell::new(None),
            })
        } else if lookahead.peek(Ident) {
            Ok(Expr::Variable {
                name: kw::ident(input)?,
                distance: Cell::new(None),
            })
        } else if lookahead.peek(Punct!["("]) {
            let content;
            let _: Parentheses = group!(content in input);
            Ok(Expr::Group(Box::new(content.parse()?)))
        } else {
            Err(lookahead.error())
        }
    }

pub fn error(self) -> Error

Generates an error based on the peek attempts.

Panics

Panics if another thread panicked while peeking through this value.

Examples found in repository

examples/calc.rs (line 91)

fn primary(input: ParseStream) -> Result<Expr> {
    let lookahead = input.lookahead();
    if lookahead.peek(token::LitFloat) {
        Ok(Expr::Num(input.parse::<token::LitFloat>()?.value()))
    } else if lookahead.peek(token::LitInt) {
        Ok(Expr::Num(input.parse::<token::LitInt>()?.value() as f64))
    } else if lookahead.peek(token::LeftParen) {
        let group: Group<Parentheses> = input.parse()?;
        parse(group.into_token_stream())
    } else {
        Err(lookahead.error())
    }
}

examples/lox/main.rs (line 414)

    fn primary(input: ParseStream) -> Result<Self> {
        let lookahead = input.lookahead();
        if lookahead.peek(kw::kw_false) {
            Ok(Expr::Literal(Literal::False(input.parse()?)))
        } else if lookahead.peek(kw::kw_true) {
            Ok(Expr::Literal(Literal::True(input.parse()?)))
        } else if lookahead.peek(kw::nil) {
            Ok(Expr::Literal(Literal::Nil(input.parse()?)))
        } else if lookahead.peek(LitFloat) {
            Ok(Expr::Literal(Literal::Float(input.parse()?)))
        } else if lookahead.peek(LitInt) {
            Ok(Expr::Literal(Literal::Int(input.parse()?)))
        } else if lookahead.peek(LitStr) {
            Ok(Expr::Literal(Literal::String(input.parse()?)))
        } else if input.peek(kw::kw_super) {
            Ok(Expr::Super {
                keyword: input.parse()?,
                distance: Cell::new(None),
                dot: input.parse()?,
                method: kw::ident(input)?,
            })
        } else if input.peek(kw::this) {
            Ok(Expr::This {
                keyword: input.parse()?,
                distance: Cell::new(None),
            })
        } else if lookahead.peek(Ident) {
            Ok(Expr::Variable {
                name: kw::ident(input)?,
                distance: Cell::new(None),
            })
        } else if lookahead.peek(Punct!["("]) {
            let content;
            let _: Parentheses = group!(content in input);
            Ok(Expr::Group(Box::new(content.parse()?)))
        } else {
            Err(lookahead.error())
        }
    }