Struct Environment

pub struct Environment<'a, 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 / FromIterator / Extend traits allow to construct environments.

Examples

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

// Load environment from the standard containers.
let mut env: Environment<'_, f64> = Prelude.iter()
    .chain(Comparisons.iter())
    // Add a custom variable for a good measure.
    .chain(vec![("x", Value::Prim(1.0))])
    .collect();

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 other_env: Environment<'_, _> = env.into_iter()
    .filter(|(_, val)| val.is_function())
    .collect();
assert!(other_env.get("x").is_none());

Implementations

impl<'a, T> Environment<'a, T>

pub fn new() -> Self

Creates a new environment.

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

Gets a variable by name.

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

Iterates over variables.

pub fn insert(&mut self, name: &str, value: Value<'a, 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<Args, F>( &mut self, name: &str, fn_to_wrap: F, ) -> &mut Self

where FnWrapper<Args, F>: 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) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, T: Debug> Debug for Environment<'a, T>

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

Formats the value using the given formatter.

impl<T> Default for Environment<'_, T>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T, S, V> Extend<(S, V)> for Environment<'a, T>

where S: Into<String>, V: Into<Value<'a, 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<'a, T, S, V> FromIterator<(S, V)> for Environment<'a, T>

where S: Into<String>, V: Into<Value<'a, T>>,

fn from_iter<I: IntoIterator<Item = (S, V)>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, T> Index<&str> for Environment<'a, T>

type Output = Value<'a, T>

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

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

The type of the elements being iterated over.

type IntoIter = Iter<'r, 'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Environment<'a, T>

type Item = (String, Value<'a, T>)

The type of the elements being iterated over.

type IntoIter = IntoIter<'a, 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 for Environment<'_, T>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a, T: Clone> VariableMap<'a, T> for Environment<'a, T>

fn get_variable(&self, name: &str) -> Option<Value<'a, T>>

Returns value of the named variable, or None if it is not defined.

fn compile_module<Id, G>( &self, id: Id, block: &Block<'a, G>, ) -> Result<ExecutableModule<'a, T>, Error<'a>>

where Id: ModuleId, G: Grammar<'a, Lit = T>, T: Clone + Debug,

Creates a module based on imports solely from this map.