Struct rustc_data_structures::unify::UnificationTable [−][src]
pub struct UnificationTable<S> where
S: UnificationStore, { /* fields omitted */ }
Table of unification keys and their values. You must define a key type K
that implements the UnifyKey
trait. Unification tables can be used in two-modes:
- in-place (
UnificationTable<InPlace<K>>
orInPlaceUnificationTable<K>
):- This is the standard mutable mode, where the array is modified in place.
- To do backtracking, you can employ the
snapshot
androllback_to
methods.
- persistent (
UnificationTable<Persistent<K>>
orPersistentUnificationTable<K>
):- In this mode, we use a persistent vector to store the data, so that cloning the table is an O(1) operation.
- This implies that ordinary operations are quite a bit slower though.
- Requires the
persistent
feature be selected in your Cargo.toml file.
Methods
impl<S> UnificationTable<S> where
S: UnificationStore,
[src]
impl<S> UnificationTable<S> where
S: UnificationStore,
pub fn new() -> UnificationTable<S>
[src]
pub fn new() -> UnificationTable<S>
pub fn snapshot(&mut self) -> Snapshot<S>
[src]
pub fn snapshot(&mut self) -> Snapshot<S>
Starts a new snapshot. Each snapshot must be either rolled back or committed in a "LIFO" (stack) order.
pub fn rollback_to(&mut self, snapshot: Snapshot<S>)
[src]
pub fn rollback_to(&mut self, snapshot: Snapshot<S>)
Reverses all changes since the last snapshot. Also removes any keys that have been created since then.
pub fn commit(&mut self, snapshot: Snapshot<S>)
[src]
pub fn commit(&mut self, snapshot: Snapshot<S>)
Commits all changes since the last snapshot. Of course, they can still be undone if there is a snapshot further out.
pub fn new_key(
&mut self,
value: <S as UnificationStore>::Value
) -> <S as UnificationStore>::Key
[src]
pub fn new_key(
&mut self,
value: <S as UnificationStore>::Value
) -> <S as UnificationStore>::Key
Creates a fresh key with the given value.
pub fn reserve(&mut self, num_new_keys: usize)
[src]
pub fn reserve(&mut self, num_new_keys: usize)
Reserve memory for num_new_keys
to be created. Does not
actually create the new keys; you must then invoke new_key
.
pub fn reset_unifications<impl FnMut(S::Key) -> S::Value>(
&mut self,
value: impl FnMut(S::Key) -> S::Value
) where
impl FnMut(S::Key) -> S::Value: FnMut(<S as UnificationStore>::Key) -> <S as UnificationStore>::Value,
[src]
pub fn reset_unifications<impl FnMut(S::Key) -> S::Value>(
&mut self,
value: impl FnMut(S::Key) -> S::Value
) where
impl FnMut(S::Key) -> S::Value: FnMut(<S as UnificationStore>::Key) -> <S as UnificationStore>::Value,
Clears all unifications that have been performed, resetting to the initial state. The values of each variable are given by the closure.
pub fn len(&self) -> usize
[src]
pub fn len(&self) -> usize
Returns the number of keys created so far.
impl<'tcx, S, K, V> UnificationTable<S> where
K: UnifyKey<Value = V>,
S: UnificationStore<Key = K, Value = V>,
V: UnifyValue,
[src]
impl<'tcx, S, K, V> UnificationTable<S> where
K: UnifyKey<Value = V>,
S: UnificationStore<Key = K, Value = V>,
V: UnifyValue,
//////////////////////////////////////////////////////////////////////// Public API
pub fn union<K1, K2>(&mut self, a_id: K1, b_id: K2) where
K1: Into<K>,
K2: Into<K>,
V: UnifyValue<Error = NoError>,
[src]
pub fn union<K1, K2>(&mut self, a_id: K1, b_id: K2) where
K1: Into<K>,
K2: Into<K>,
V: UnifyValue<Error = NoError>,
Unions two keys without the possibility of failure; only
applicable when unify values use NoError
as their error
type.
pub fn union_value<K1>(&mut self, id: K1, value: V) where
K1: Into<K>,
V: UnifyValue<Error = NoError>,
[src]
pub fn union_value<K1>(&mut self, id: K1, value: V) where
K1: Into<K>,
V: UnifyValue<Error = NoError>,
Unions a key and a value without the possibility of failure;
only applicable when unify values use NoError
as their error
type.
pub fn unioned<K1, K2>(&mut self, a_id: K1, b_id: K2) -> bool where
K1: Into<K>,
K2: Into<K>,
[src]
pub fn unioned<K1, K2>(&mut self, a_id: K1, b_id: K2) -> bool where
K1: Into<K>,
K2: Into<K>,
Given two keys, indicates whether they have been unioned together.
pub fn find<K1>(&mut self, id: K1) -> K where
K1: Into<K>,
[src]
pub fn find<K1>(&mut self, id: K1) -> K where
K1: Into<K>,
Given a key, returns the (current) root key.
pub fn unify_var_var<K1, K2>(
&mut self,
a_id: K1,
b_id: K2
) -> Result<(), <V as UnifyValue>::Error> where
K1: Into<K>,
K2: Into<K>,
[src]
pub fn unify_var_var<K1, K2>(
&mut self,
a_id: K1,
b_id: K2
) -> Result<(), <V as UnifyValue>::Error> where
K1: Into<K>,
K2: Into<K>,
Unions together two variables, merging their values. If merging the values fails, the error is propagated and this method has no effect.
pub fn unify_var_value<K1>(
&mut self,
a_id: K1,
b: V
) -> Result<(), <V as UnifyValue>::Error> where
K1: Into<K>,
[src]
pub fn unify_var_value<K1>(
&mut self,
a_id: K1,
b: V
) -> Result<(), <V as UnifyValue>::Error> where
K1: Into<K>,
Sets the value of the key a_id
to b
, attempting to merge
with the previous value.
pub fn probe_value<K1>(&mut self, id: K1) -> V where
K1: Into<K>,
[src]
pub fn probe_value<K1>(&mut self, id: K1) -> V where
K1: Into<K>,
Returns the current value for the given key. If the key has been union'd, this will give the value from the current root.
Trait Implementations
impl<S> Clone for UnificationTable<S> where
S: UnificationStore + Clone,
[src]
impl<S> Clone for UnificationTable<S> where
S: UnificationStore + Clone,
fn clone(&self) -> UnificationTable<S>
[src]
fn clone(&self) -> UnificationTable<S>
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
impl<S> Debug for UnificationTable<S> where
S: UnificationStore + Debug,
[src]
impl<S> Debug for UnificationTable<S> where
S: UnificationStore + Debug,
Auto Trait Implementations
impl<S> Send for UnificationTable<S> where
S: Send,
impl<S> Send for UnificationTable<S> where
S: Send,
impl<S> Sync for UnificationTable<S> where
S: Sync,
impl<S> Sync for UnificationTable<S> where
S: Sync,