Struct Assoc 

pub struct Assoc<K, V>
where
    K: Eq + Hash + Clone,
{ /* private fields */ }

A persistent key-value store. clone, set, and find are sub-linear.

Implementations

impl<K: Eq + Hash + Clone, V: Clone> Assoc<K, V>

pub fn new() -> Self

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

pub fn set(&self, key: K, value: V) -> Self

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

pub fn mut_set(&mut self, key: K, value: V)

pub fn single(key: K, value: V) -> Self

pub fn empty(&self) -> bool

pub fn iter_pairs(&self) -> Iter<'_, K, V>

pub fn iter_keys(&self) -> Keys<'_, K, V>

pub fn iter_values(&self) -> Values<'_, K, V>

pub fn map<NewV: Clone, F>(&self, f: F) -> Assoc<K, NewV>

where F: FnMut(&V) -> NewV,

pub fn map_borrow_f<'assoc, NewV: Clone, F>( &'assoc self, f: &mut F, ) -> Assoc<K, NewV>

where F: FnMut(&'assoc V) -> NewV,

pub fn keyed_map_borrow_f<NewV: Clone, F>(&self, f: &mut F) -> Assoc<K, NewV>

where F: FnMut(&K, &V) -> NewV,

pub fn map_with<OtherV: Clone, NewV: Clone>( &self, other: &Assoc<K, OtherV>, f: &dyn Fn(&V, &OtherV) -> NewV, ) -> Assoc<K, NewV>

pub fn keyed_map_with<OtherV: Clone, NewV: Clone>( &self, other: &Assoc<K, OtherV>, f: &dyn Fn(&K, &V, &OtherV) -> NewV, ) -> Assoc<K, NewV>

pub fn find_value<'assoc, 'f>(&'assoc self, target: &'f V) -> Option<&'assoc K>

where V: PartialEq,

pub fn find_or_panic<'assoc, 'f>(&'assoc self, target: &'f K) -> &'assoc V

where K: Display,

pub fn remove<'assoc, 'f>(&'assoc mut self, target: &'f K) -> Option<V>

pub fn remove_or_panic<'assoc, 'f>(&'assoc mut self, target: &'f K) -> V

where K: Display,

pub fn cut_common(&self, other: &Assoc<K, V>) -> Assoc<K, V>

where V: PartialEq,

pub fn unset(&self, k: &K) -> Assoc<K, V>

pub fn reduce<Out>(&self, red: &dyn Fn(&K, &V, Out) -> Out, base: Out) -> Out

impl<K: Eq + Hash + Clone, V: Clone> Assoc<K, V>

pub fn almost_ptr_eq(&self, other: &Assoc<K, V>) -> bool

impl<K: Eq + Hash + Clone, V: Clone, E: Clone> Assoc<K, Result<V, E>>

pub fn lift_result(self) -> Result<Assoc<K, V>, E>

impl<T: Clone> Assoc<Name, AsterismSlice<'_, T>>

pub fn to_sky(&self) -> Assoc<Name, Asterism<T>>

impl<T: Clone> Assoc<Name, Asterism<T>>

pub fn new_from_leaves(l: Assoc<Name, T>) -> Self

pub fn new_from_named_repeat(_n: Name, r: Vec<Self>) -> Self

👎Deprecated

pub fn new_from_anon_repeat(r: Vec<Self>) -> Self

pub fn leaf(&self, n: Name) -> &T

pub fn depth_1<'b>(&'b self, n: Name) -> Box<dyn Iterator<Item = &'b T> + 'b>

pub fn to_sky_slices<'b>(&'b self) -> Assoc<Name, AsterismSlice<'b, T>>

pub fn march<'b>( &'b self, driving_names: &'b [Name], ) -> Box<dyn Iterator<Item = Assoc<Name, AsterismSlice<'b, T>>> + 'b>

pub fn add_leaf(&mut self, n: Name, v: T)

pub fn add_named_repeat(&mut self, _: Name, sub: Vec<Assoc<Name, Asterism<T>>>)

👎Deprecated: inefficent, and named repeats are gone

pub fn add_anon_repeat(&mut self, sub: Vec<Assoc<Name, Asterism<T>>>)

👎Deprecated: inefficent

pub fn anonimize_repeat(&mut self, _: Name)

👎Deprecated: named repeats are gone

Trait Implementations

impl<K, V: Clone> Clone for Assoc<K, V>

where K: Eq + Hash + Clone + Clone,

fn clone(&self) -> Assoc<K, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Eq + Hash + Clone + Debug, V: Clone + Debug> Debug for Assoc<K, V>

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

Formats the value using the given formatter.

impl<K: Eq + Hash + Clone, V: Clone> Default for Assoc<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<K: Eq + Hash + Clone + Display, V: Clone + Display> Display for Assoc<K, V>

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

Formats the value using the given formatter.

impl From<Assoc<Name, Ast>> for Ren

fn from(a: Assoc<Name, Ast>) -> Ren

Converts to this type from the input type.

impl<K: Eq + Hash + Clone, V: Clone + PartialEq> PartialEq for Assoc<K, V>

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<K: Eq + Hash + Clone + Reifiable, V: Clone + Reifiable> Reifiable for Assoc<K, V>

fn ty_name() -> Name

A name for that type, so that recursive types are okay. Ignore the type parameters of Self; invoke like Self::<Irr,Irr>::ty_name(). e.g. WithInteger

fn concrete_arguments() -> Option<Vec<Ast>>

fn reify(&self) -> Value

The Unseemly value that corresponds to a value.

fn reflect(v: &Value) -> Self

Get a value from an Unseemly value

fn ty() -> Ast

The Unseemly type that corresponds to to the Reifiable type. This leaves abstract the type parameters of Self; invoke like Self::<Irr,Irr>::ty(). e.g. ∀ A. Pair<A int> TODO: rename to generic_ty

fn ty_invocation() -> Ast

How to refer to this type, given an environment in which ty_name() is defined to be ty(). Parameters will be concrete. e.g. WithInteger<Float> (Types using this type will use this, rather than ty) Don’t override this.

impl<K: Eq + Hash + Clone, V: Clone + Eq> Eq for Assoc<K, V>