Struct ExprParser

pub struct ExprParser { /* private fields */ }

Main struct for parsing and evaluating expr programs

Example:

use std::collections::HashMap;
use expr::ExprParser;
let ctx = HashMap::from([("foo", 1), ("bar", 2)]);
let p = ExprParser::new(ctx);
assert_eq!(p.eval("foo + bar").unwrap().to_string(), "3");

Implementations

impl ExprParser

pub fn new<K, V>(ctx: impl IntoIterator<Item = (K, V)>) -> Self

where K: AsRef<str>, V: Into<ExprValue>,

Create a new parser with a context struct containing variables

pub fn add_function( &mut self, name: &str, f: fn(_: Vec<ExprValue>) -> ExprValue, )

Add a function for expr programs to call

Example:

use expr::{ExprParser, ExprValue};

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

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

Parse an expr program to be run later

pub fn run(&self, program: ExprProgram) -> Result<ExprValue, ExprError>

Run a compiled expr program

pub fn eval(&self, code: &str) -> Result<ExprValue, ExprError>

Compile and run an expr program in one step

Example:

use expr::ExprParser;
let p = ExprParser::default();
assert_eq!(p.eval("1 + 2").unwrap().to_string(), "3");

Trait Implementations

impl Clone for ExprParser

fn clone(&self) -> ExprParser

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExprParser

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

Formats the value using the given formatter.

impl Default for ExprParser

fn default() -> ExprParser

Returns the “default value” for a type.