Struct seax_util::compiler_tools::forktable::ForkTable
[−]
[src]
pub struct ForkTable<'a, K, V> where
K: Eq + Hash,
K: 'a,
V: 'a, { /* fields omitted */ }
An associative map data structure for representing scopes.
A ForkTable
functions similarly to a standard associative map
data structure (such as a HashMap
), but with the ability to
fork children off of each level of the map. If a key exists in any
of a child's parents, the child will 'pass through' that key. If a
new value is bound to a key in a child level, that child will overwrite
the previous entry with the new one, but the previous key
-> value
mapping will remain in the level it is defined. This means that the parent
level will still provide the previous value for that key.
This is an implementation of the ForkTable data structure for representing scopes. The ForkTable was initially described by Max Clive. This implemention is based primarily by the Scala reference implementation written by Hawk Weisman for the Decaf compiler, which is available here.
Methods
impl<'a, K, V> ForkTable<'a, K, V> where
K: Eq + Hash,
[src]
K: Eq + Hash,
fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V> where
K: Borrow<Q>,
Q: Hash + Eq,
K: Borrow<Q>,
Q: Hash + Eq,
Returns a reference to the value corresponding to the key.
If the key is defined in this level of the table, or in any of its' parents, a reference to the associated value will be returned.
The key may be any borrowed form of the map's key type, but
Hash
and Eq
on the borrowed form must match those for
the key type.
Arguments
key
- the key to search for
Return Value
Some(&V)
if an entry for the given key exists in the table, orNone
if there is no entry for that key.
Examples
let mut table: ForkTable<isize,&str> = ForkTable::new(); assert_eq!(table.get(&1), None); table.insert(1, "One"); assert_eq!(table.get(&1), Some(&"One")); assert_eq!(table.get(&2), None);
let mut level_1: ForkTable<isize,&str> = ForkTable::new(); level_1.insert(1, "One"); let mut level_2: ForkTable<isize,&str> = level_1.fork(); assert_eq!(level_2.get(&1), Some(&"One"));
fn get_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut V> where
K: Borrow<Q>,
Q: Hash + Eq,
K: Borrow<Q>,
Q: Hash + Eq,
Returns a mutable reference to the value corresponding to the key.
If the key is defined in this level of the table, a reference to the associated value will be returned.
Note that only keys defined in this level of the table can be accessed as mutable. This is because otherwise it would be necessary for each level of the table to hold a mutable reference to its parent.
The key may be any borrowed form of the map's key type, but
Hash
and Eq
on the borrowed form must match those for
the key type.
Arguments
key
- the key to search for
Return Value
Some(&mut V)
if an entry for the given key exists in the table, orNone
if there is no entry for that key.
Examples
let mut table: ForkTable<isize,&str> = ForkTable::new(); assert_eq!(table.get_mut(&1), None); table.insert(1isize, "One"); assert_eq!(table.get_mut(&1), Some(&mut "One")); assert_eq!(table.get_mut(&2), None);
let mut level_1: ForkTable<isize,&str> = ForkTable::new(); level_1.insert(1, "One"); let mut level_2: ForkTable<isize,&str> = level_1.fork(); assert_eq!(level_2.get_mut(&1), None);
fn remove(&mut self, key: &K) -> Option<V> where
K: Clone,
K: Clone,
Removes a key from the map, returning the value at the key if the key was previously in the map.
If the removed value exists in a lower level of the table, it will be whited out at this level. This means that the entry will be 'removed' at this level and this table will not provide access to it, but the mapping will still exist in the level where it was defined. Note that the key will not be returned if it is defined in a lower level of the table.
The key may be any borrowed form of the map's key type, but
Hash
and Eq
on the borrowed form must match those for
the key type.
Arguments
key
- the key to remove
Return Value
Some(V)
if an entry for the given key exists in the table, orNone
if there is no entry for that key.
Examples
let mut table: ForkTable<isize,&str> = ForkTable::new(); table.insert(1, "One"); assert_eq!(table.remove(&1), Some("One")); assert_eq!(table.contains_key(&1), false);
let mut level_1: ForkTable<isize,&str> = ForkTable::new(); level_1.insert(1, "One"); assert_eq!(level_1.contains_key(&1), true); let mut level_2: ForkTable<isize,&str> = level_1.fork(); assert_eq!(level_2.chain_contains_key(&1), true); assert_eq!(level_2.remove(&1), None); assert_eq!(level_2.chain_contains_key(&1), false);
fn insert(&mut self, k: K, v: V) -> Option<V>
Inserts a key-value pair from the map.
If the key already had a value present in the map, that
value is returned. Otherwise, None
is returned.
If the key is currently whited out (i.e. it was defined in a lower level of the map and was removed) then it will be un-whited out and added at this level.
Arguments
k
- the key to addv
- the value to associate with that key
Return Value
Some(V)
if a previous entry for the given key exists in the table, orNone
if there is no entry for that key.
Examples
Simply inserting an entry:
let mut table: ForkTable<isize,&str> = ForkTable::new(); assert_eq!(table.get(&1), None); table.insert(1, "One"); assert_eq!(table.get(&1), Some(&"One"));
Overwriting the value associated with a key:
let mut table: ForkTable<isize,&str> = ForkTable::new(); assert_eq!(table.get(&1), None); assert_eq!(table.insert(1, "one"), None); assert_eq!(table.get(&1), Some(&"one")); assert_eq!(table.insert(1, "One"), Some("one")); assert_eq!(table.get(&1), Some(&"One"));
fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool where
K: Borrow<Q>,
Q: Hash + Eq,
K: Borrow<Q>,
Q: Hash + Eq,
Returns true if this level contains a value for the specified key.
The key may be any borrowed form of the map's key type, but
Hash
and Eq
on the borrowed form must match those for
the key type.
Arguments
k
- the key to search for
Return Value
true
if the given key is defined in this level of the table,false
if it does not.
Examples
let mut table: ForkTable<isize,&str> = ForkTable::new(); assert_eq!(table.contains_key(&1), false); table.insert(1, "One"); assert_eq!(table.contains_key(&1), true);
let mut level_1: ForkTable<isize,&str> = ForkTable::new(); assert_eq!(level_1.contains_key(&1), false); level_1.insert(1, "One"); assert_eq!(level_1.contains_key(&1), true); let mut level_2: ForkTable<isize,&str> = level_1.fork(); assert_eq!(level_2.contains_key(&1), false);
fn chain_contains_key<Q: ?Sized>(&self, key: &Q) -> bool where
K: Borrow<Q>,
Q: Hash + Eq,
K: Borrow<Q>,
Q: Hash + Eq,
Returns true if the key is defined in this level of the table, or in any of its' parents and is not whited out.
The key may be any borrowed form of the map's key type, but
Hash
and Eq
on the borrowed form must match those for
the key type.
Arguments
k
- the key to search for
Return Value
true
if the given key is defined in the table,false
if it does not.
Examples
let mut table: ForkTable<isize,&str> = ForkTable::new(); assert_eq!(table.chain_contains_key(&1), false); table.insert(1, "One"); assert_eq!(table.chain_contains_key(&1), true);
let mut level_1: ForkTable<isize,&str> = ForkTable::new(); assert_eq!(level_1.chain_contains_key(&1), false); level_1.insert(1, "One"); assert_eq!(level_1.chain_contains_key(&1), true); let mut level_2: ForkTable<isize,&str> = level_1.fork(); assert_eq!(level_2.chain_contains_key(&1), true);
fn fork(&'a self) -> ForkTable<'a, K, V>
Forks this table, returning a new ForkTable<K,V>
.
This level of the table will be set as the child's
parent. The child will be created with an empty backing
HashMap
and no keys whited out.
Note that the new ForkTable<K,V>
has a lifetime
bound ensuring that it will live at least as long as the
parent ForkTable
.
fn new() -> ForkTable<'a, K, V>
Constructs a new ForkTable<K,V>
fn values<'b>(&'b self) -> Values<'b, K, V>
Wrapper for the backing map's values()
function.
Provides an iterator visiting all values in arbitrary order. Iterator element type is &'b V.
fn keys<'b>(&'b self) -> Keys<'b, K, V>
Wrapper for the backing map's keys()
function.
Provides an iterator visiting all keys in arbitrary order. Iterator element type is &'b K.
Trait Implementations
impl<'a, K: Debug, V: Debug> Debug for ForkTable<'a, K, V> where
K: Eq + Hash,
K: 'a,
V: 'a,
[src]
K: Eq + Hash,
K: 'a,
V: 'a,
impl<'a, 'b, K, Q: ?Sized, V> Index<&'b Q> for ForkTable<'a, K, V> where
K: Borrow<Q>,
K: Eq + Hash,
Q: Eq + Hash,
[src]
K: Borrow<Q>,
K: Eq + Hash,
Q: Eq + Hash,
Allows table[&key]
indexing syntax.
This is just a wrapper for get(&key)
let mut table: ForkTable<isize,&str> = ForkTable::new(); table.insert(1, "One"); assert_eq!(table[&1], "One");
type Output = V
The returned type after indexing
fn index(&self, index: &Q) -> &Self::Output
The method for the indexing (container[index]
) operation
impl<'a, 'b, K, Q: ?Sized, V> IndexMut<&'b Q> for ForkTable<'a, K, V> where
K: Borrow<Q>,
K: Eq + Hash,
Q: Eq + Hash,
[src]
K: Borrow<Q>,
K: Eq + Hash,
Q: Eq + Hash,
Allows mutable table[&key]
indexing syntax.
This is just a wrapper for get_mut(&key)
let mut table: ForkTable<isize,&str> = ForkTable::new(); table.insert(1, "One"); table[&1] = "one"; assert_eq!(table[&1], "one")
fn index_mut(&mut self, index: &Q) -> &mut V
The method for the mutable indexing (container[index]
) operation