Struct rune::Parser

pub struct Parser<'a> { /* fields omitted */ }

Parser for the rune language.

Examples

use rune::{ast, Parser};

let mut parser = Parser::new("fn foo() {}");
parser.parse::<ast::ItemFn>().unwrap();

Implementations

impl<'a> Parser<'a>

pub fn new(source: &'a str) -> Self

Construct a new parser around the given source.

pub fn try_consume<T>(&mut self) -> Result<bool, ParseError> where
    T: Parse + Peek, 

Try to consume a single thing matching T, returns true if any tokens were consumed.

pub fn try_consume_all<T>(&mut self) -> Result<bool, ParseError> where
    T: Parse + Peek, 

Try to consume all things matching T, returns true if any tokens were consumed.

pub fn from_token_stream(token_stream: &'a TokenStream) -> Self

Construct a parser from a token stream.

pub fn span(&mut self, range: Range<usize>) -> Span

Get the span for the given range offset of tokens.

pub fn parse<T>(&mut self) -> Result<T, ParseError> where
    T: Parse, 

Parse a specific item from the parser.

pub fn parse_all<T>(&mut self) -> Result<T, ParseError> where
    T: Parse, 

Parse a specific item from the parser and then expect end of input.

pub fn peek<T>(&mut self) -> Result<bool, ParseError> where
    T: Peek, 

Peek for the given token.

pub fn peeker(&mut self) -> &mut Peeker<'a>

Access the interior peeker of the parser.

pub fn next(&mut self) -> Result<Token, ParseError>

Consume the next token from the parser.

pub fn is_eof(&mut self) -> Result<bool, ParseError>

Test if the parser is at end-of-file, after which there is no more input to parse.

pub fn eof(&mut self) -> Result<(), ParseError>

Assert that the parser has reached its end-of-file.

pub fn nth(&mut self, n: usize) -> Result<Kind, ParseError>

Peek the token kind at the given position.

pub fn span_at(&mut self, n: usize) -> Span

Get the span for the given offset.

pub fn tok_at(&mut self, n: usize) -> Result<Token, ParseError>

Get the span at the given position.

pub fn last_span(&self) -> Span

The last known span in this parser.

Trait Implementations

impl<'a> Debug for Parser<'a>

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

Formats the value using the given formatter.