Struct arithmetic_eval::Environment

pub struct Environment<'a, T> { /* fields omitted */ }

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::Number(1.0))])
    .collect();

assert_eq!(env["true"], Value::Bool(true));
assert_eq!(env["x"], Value::Number(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>

pub fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

pub 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>>, 

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

Extends a collection with the contents of an iterator.

pub fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

pub 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>>, 

pub 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.

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

Performs the indexing (container[index]) operation.

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?

pub fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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?

pub fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq, '_> PartialEq<Environment<'_, T>> for Environment<'_, T>

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

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

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

pub fn compile_module<Id, G>(
    &self,
    id: Id,
    block: &Block<'a, G>
) -> Result<ExecutableModule<'a, T>, Error<'a>> where
    Id: ModuleId,
    G: Grammar<Lit = T>,
    T: Clone + Debug, 

Creates a module based on imports solely from this map.