Struct Parser

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

👎Deprecated: Use compile() and Environment instead

Main struct for parsing and evaluating expr programs

Example:

use expr::{Context, Parser};
let ctx = Context::from_iter([("foo", 1), ("bar", 2)]);
let p = Parser::new();
assert_eq!(p.eval("foo + bar", &ctx).unwrap().to_string(), "3");

Implementations

impl<'a> Parser<'a>

pub fn new() -> Self

Create a new parser with the default environment

pub fn add_function<F>(&mut self, name: &str, f: F)

where F: Fn(ExprCall<'_, '_>) -> Result<Value> + 'a + Sync + Send,

Add a function for expr programs to call

Example:

use std::collections::HashMap;
use expr::{Context, Parser, Value};

let mut p = Parser::new();
let ctx = Context::default();
p.add_function("add", |c| {
  let mut sum = 0;
    for arg in c.args {
      if let Value::Number(n) = arg {
        sum += n;
       } else {
         panic!("Invalid argument: {arg:?}");
       }
    }
  Ok(sum.into())
});
assert_eq!(p.eval("add(1, 2, 3)", &ctx).unwrap().to_string(), "6");

pub fn compile(&self, code: &str) -> Result<Program>

Parse an expr program to be run later

pub fn run(&self, program: Program, ctx: &Context) -> Result<Value>

Run a compiled expr program

pub fn eval(&self, code: &str, ctx: &Context) -> Result<Value>

Compile and run an expr program in one step

Example:

use std::collections::HashMap;
use expr::{Context, Parser};
let p = Parser::default();
let ctx = Context::default();
assert_eq!(p.eval("1 + 2", &ctx).unwrap().to_string(), "3");

pub fn eval_expr(&self, ctx: &Context, node: Node) -> Result<Value>

Trait Implementations

impl Debug for Parser<'_>

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

Formats the value using the given formatter.

impl<'a> Default for Parser<'a>

fn default() -> Parser<'a>

Returns the “default value” for a type.