Struct Environment

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

Struct containing custom environment setup for expr evaluation (e.g. custom function definitions)

Example:

use expr::{Context, Environment, Value};
let mut env = Environment::new();
let ctx = Context::default();
env.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!(env.eval("add(1, 2, 3)", &ctx).unwrap().to_string(), "6");

Implementations

impl Environment<'_>

pub fn eval_operator( &self, ctx: &Context, operator: Operator, left: Node, right: Node, ) -> Result<Value>

impl Environment<'_>

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

impl Environment<'_>

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

impl<'a> Environment<'a>

pub fn new() -> Self

Create a new environment with default set of functions

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 expr::{Context, Environment, Value};
let mut env = Environment::new();
let ctx = Context::default();
env.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!(env.eval("add(1, 2, 3)", &ctx).unwrap().to_string(), "6");

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, Environment};
let env = Environment::new();
let ctx = Context::default();
assert_eq!(env.eval("1 + 2", &ctx).unwrap().to_string(), "3");

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

impl Environment<'_>

pub fn eval_func( &self, ctx: &Context, ident: String, args: Vec<Value>, predicate: Option<Program>, ) -> Result<Value>

Trait Implementations

impl Debug for Environment<'_>

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

Formats the value using the given formatter.

impl<'a> Default for Environment<'a>

fn default() -> Environment<'a>

Returns the “default value” for a type.