Enum Var 

pub enum Var<N> {
    Free(FreeVar<N>),
    Bound(BoundVar<N>),
}

A variable that can either be free or bound

Variants

Free(FreeVar<N>)

A free variable

Bound(BoundVar<N>)

A variable that is bound by a scope

Implementations

impl<N> Var<N>

pub fn pretty_name(&self) -> Option<&N>

Trait Implementations

impl<N: Clone + PartialEq> BoundTerm<N> for Var<N>

fn term_eq(&self, other: &Var<N>) -> bool

Alpha equivalence for terms

fn close_term(&mut self, state: ScopeState, on_free: &impl OnFreeFn<N>)

Close the term using the supplied binders

fn open_term(&mut self, state: ScopeState, on_bound: &impl OnBoundFn<N>)

Open the term using the supplied binders

fn visit_vars(&self, on_var: &mut impl FnMut(&Var<N>))

Visit each variable in the term, calling the on_var callback on each of them in turn

fn visit_mut_vars(&mut self, on_var: &mut impl FnMut(&mut Var<N>))

Visit each variable in the term, calling the on_var callback on each of them in turn

fn free_vars(&self) -> HashSet<FreeVar<N>>

where N: Eq + Hash + Clone,

Returns the set of free variables in this term

impl<N: Clone> Clone for Var<N>

fn clone(&self) -> Var<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: Debug> Debug for Var<N>

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

Formats the value using the given formatter.

impl<N: Display> Display for Var<N>

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

Formats the value using the given formatter.

impl<N: Hash> Hash for Var<N>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<N> PartialEq<Binder<N>> for Var<N>

where N: PartialEq,

fn eq(&self, other: &Binder<N>) -> 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<N> PartialEq<FreeVar<N>> for Var<N>

where N: PartialEq,

fn eq(&self, other: &FreeVar<N>) -> 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<N> PartialEq<Var<N>> for Binder<N>

where N: PartialEq,

fn eq(&self, other: &Var<N>) -> 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<N> PartialEq<Var<N>> for FreeVar<N>

where N: PartialEq,

fn eq(&self, other: &Var<N>) -> 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<N: PartialEq> PartialEq for Var<N>

fn eq(&self, other: &Var<N>) -> 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<N> Eq for Var<N>

where N: Eq,

impl<N> StructuralPartialEq for Var<N>