Enum LexicalScope 

pub enum LexicalScope<K, V> {
    Empty,
    Root(Box<HashMap<K, V>>),
    Nested(Rc<LexicalScope<K, V>>, Box<HashMap<K, V>>),
}

A lexically scoped environment is essentially a hierarchical mapping of keys to values, where keys may be defined at multiple levels, but only a single definition at any point in the program is active - the definition closest to that point.

A LexicalScope starts out at the root, empty. Any number of keys may be inserted at the current scope, or a new nested scope may be entered. When entering a new nested scope, keys inserted there take precedence over the same keys in previous (higher) scopes, but do not overwrite those definitions. When exiting a scope, all definitions in that scope are discarded, and definitions from the parent scope take effect again.

When searching for keys, the search begins in the current scope, and searches upwards in the scope tree until either the root is reached and the search terminates, or the key is found in some intervening scope.

Variants

Empty

An empty scope, this is the default state in which all LexicalScope start

Root(Box<HashMap<K, V>>)

Represents a non-empty, top-level (root) scope

Nested(Rc<LexicalScope<K, V>>, Box<HashMap<K, V>>)

Represents a (possibly empty) nested scope, as a tuple of the parent scope and the environment of the current scope.

Implementations

impl<K, V> LexicalScope<K, V>

pub fn is_empty(&self) -> bool

Returns true if this scope is empty

impl<K, V> LexicalScope<K, V>

where K: Clone, V: Clone,

pub fn enter(&mut self)

Returns true if this scope is empty Enters a new, nested lexical scope

pub fn exit(&mut self)

Exits the current lexical scope

impl<K, V> LexicalScope<K, V>

where K: Eq + Hash,

pub fn insert(&mut self, k: K, v: V) -> Option<V>

Inserts a new binding in the current scope, returning a conflicting definition if one is present (i.e. the same name was already declared in the same (current) scope).

NOTE: This does not return Some if a previous definition exists in an outer scope, the new definition will shadow that one, but is not considered in conflict with it.

pub fn get<Q>(&self, key: &Q) -> Option<&V>

where K: Borrow<Q>, Q: Eq + Hash + ?Sized,

pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>

where K: Borrow<Q>, Q: Eq + Hash + ?Sized,

pub fn get_key_value<Q>(&self, key: &Q) -> Option<(&K, &V)>

where K: Borrow<Q>, Q: Eq + Hash + ?Sized,

pub fn get_key<Q>(&self, key: &Q) -> Option<&K>

where K: Borrow<Q>, Q: Eq + Hash + ?Sized,

Gets the value of the key stored in this structure by key

This is used in some cases where a field of the key contains useful metadata (such as source spans), but is not part of the eq/hash impl. This function allows you to obtain the actual key stored in the map.

Trait Implementations

impl<K, V> Clone for LexicalScope<K, V>

where K: Clone, V: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug> Debug for LexicalScope<K, V>

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

Formats the value using the given formatter.

impl<K, V> Default for LexicalScope<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<K, V, Q> Index<&Q> for LexicalScope<K, V>

where K: Eq + Hash + Borrow<Q>, Q: Eq + Hash + ?Sized,

type Output = V

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<K, V, Q> IndexMut<&Q> for LexicalScope<K, V>

where K: Eq + Hash + Borrow<Q>, Q: Eq + Hash + ?Sized,

fn index_mut(&mut self, key: &Q) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.