Struct Parser 

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

A Pratt parser for Swan expressions.

Create one with Parser::new and call Parser::parse once to get the root node of the expression.

Implementations

impl<'a> Parser<'a>

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

Creates a new parser wrapping lexer and pre-loads the look-ahead.

pub fn parse_expr(&mut self, min_bp: u32) -> Node

Parses a single complete expression at the given minimum binding power.

min_bp is the binding power of the operator that called us. We only consume infix operators whose left-binding-power is GREATER than min_bp; everything else is left for the caller to handle.

Call with min_bp = 0 to parse a full expression.

Algorithm (step by step)

1. Parse a PREFIX production → gives us the left-hand node (lhs).
2. Loop: a. Skip comments and peek at the next token. b. If lbp(peek) <= min_bp → STOP; return lhs. c. Consume the infix token (advance). d. Recursively parse the rhs with min_bp = rbp(infix_token). e. Combine lhs + rhs into a new node; that becomes the new lhs.

pub fn parse(&mut self) -> Node

Parses the entire input as a single expression and returns its root node.

An empty source (or one containing only comments) gives Node::Nothing. Parsing never fails; see the module documentation for how syntax errors are represented.

Examples

use swan_core::lexer::Lexer;
use swan_core::parser::Parser;

let lexer = Lexer::new("1 + 2 * 3");
let mut parser = Parser::new(lexer);
let ast = parser.parse();   // SumOp(1, ProductOp(2, 3))