Struct arithmetic_eval::env::Environment

pub struct Environment<T> { /* private fields */ }

Environment containing named Values.

Note that the environment implements the Index trait, which allows to eloquently access or modify environment. Similarly, IntoIterator / Extend traits allow to construct environments.

Examples

use arithmetic_eval::{env::{Comparisons, Prelude}, Environment, Value};

// Load environment from the standard containers.
let mut env = Environment::<f64>::new();
env.extend(Prelude::iter().chain(Comparisons::iter()));
// Add a custom variable for a good measure.
env.insert("x", Value::Prim(1.0));

assert_eq!(env["true"], Value::Bool(true));
assert_eq!(env["x"], Value::Prim(1.0));
for (name, value) in &env {
    println!("{name} -> {value:?}");
}

// It's possible to base an environment on other env, as well.
let mut other_env = Environment::new();
other_env.extend(
    env.into_iter().filter(|(_, val)| val.is_function()),
);
assert!(other_env.get("x").is_none());

Implementations

impl<T> Environment<T>where StdArithmetic: OrdArithmetic<T>,

pub fn new() -> Self

Creates a new environment.

impl<T> Environment<T>

pub fn with_arithmetic<A>(arithmetic: A) -> Selfwhere A: OrdArithmetic<T> + 'static,

Creates an environment with the specified arithmetic.

pub fn get(&self, name: &str) -> Option<&Value<T>>

Gets a variable by name.

pub fn contains(&self, name: &str) -> bool

Checks if this environment contains a variable with the specified name.

pub fn iter(&self) -> impl Iterator<Item = (&str, &Value<T>)> + '_

Iterates over variables.

pub fn insert(&mut self, name: &str, value: Value<T>) -> &mut Self

Inserts a variable with the specified name.

pub fn insert_native_fn( &mut self, name: &str, native_fn: impl NativeFn<T> + 'static ) -> &mut Self

Inserts a native function with the specified name.

pub fn insert_wrapped_fn<const CTX: bool, Args, F>( &mut self, name: &str, fn_to_wrap: F ) -> &mut Selfwhere FnWrapper<Args, F, CTX>: NativeFn<T> + 'static,

Inserts a wrapped function with the specified name.

Calling this method is equivalent to wrapping a function and calling insert_native_fn() on it. Thanks to type inference magic, the Rust compiler will usually be able to extract the Args type param from the function definition, provided that type of function arguments and its return type are defined explicitly or can be unequivocally inferred from the declaration.

Trait Implementations

impl<T: Clone> Clone for Environment<T>

fn clone(&self) -> Environment<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Environment<T>

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

Formats the value using the given formatter.

impl<T> Default for Environment<T>where StdArithmetic: OrdArithmetic<T>,

fn default() -> Self

Returns the “default value” for a type.

impl<T, S, V> Extend<(S, V)> for Environment<T>where S: Into<String>, V: Into<Value<T>>,

fn extend<I: IntoIterator<Item = (S, V)>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T> Index<&str> for Environment<T>

type Output = Value<T>

The returned type after indexing.

fn index(&self, index: &str) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'r, T> IntoIterator for &'r Environment<T>

type Item = (&'r str, &'r Value<T>)

The type of the elements being iterated over.

type IntoIter = Iter<'r, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for Environment<T>

type Item = (String, Value<T>)

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq<Environment<T>> for Environment<T>

Compares environments by variables; arithmetics are ignored.

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.