Trait moniker::BoundTerm

pub trait BoundTerm<N> {
    fn term_eq(&self, other: &Self) -> bool;
    fn close_term(&mut self, state: ScopeState, binders: &[Binder<N>]);
    fn open_term(&mut self, state: ScopeState, binders: &[Binder<N>]);
    fn visit_vars(
        &self, 
        on_var: &mut impl FnMut(&Var<N>)
    );
    fn visit_mut_vars(
        &mut self, 
        on_var: &mut impl FnMut(&mut Var<N>)
    );

    fn free_vars(&self) -> HashSet<FreeVar<N>>
    where
        N: Eq + Hash + Clone,
    { ... }
}

Terms that may contain variables that can be bound by patterns

Required Methods

fn term_eq(&self, other: &Self) -> bool

Alpha equivalence in a term context

fn close_term(&mut self, state: ScopeState, binders: &[Binder<N>])

fn open_term(&mut self, state: ScopeState, binders: &[Binder<N>])

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

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

Provided Methods

fn free_vars(&self) -> HashSet<FreeVar<N>> where
    N: Eq + Hash + Clone, 

Returns the set of free variables in this term

Implementations on Foreign Types

impl<N> BoundTerm<N> for ()

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

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for String

fn term_eq(&self, other: &String) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for str

fn term_eq(&self, other: &str) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for char

fn term_eq(&self, other: &char) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for bool

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

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for u8

fn term_eq(&self, other: &u8) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for u16

fn term_eq(&self, other: &u16) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for u32

fn term_eq(&self, other: &u32) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for u64

fn term_eq(&self, other: &u64) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for usize

fn term_eq(&self, other: &usize) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for i8

fn term_eq(&self, other: &i8) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for i16

fn term_eq(&self, other: &i16) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for i32

fn term_eq(&self, other: &i32) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for i64

fn term_eq(&self, other: &i64) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for isize

fn term_eq(&self, other: &isize) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for f32

fn term_eq(&self, other: &f32) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for f64

fn term_eq(&self, other: &f64) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for ByteIndex

fn term_eq(&self, _: &ByteIndex) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for ByteOffset

fn term_eq(&self, _: &ByteOffset) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for ColumnIndex

fn term_eq(&self, _: &ColumnIndex) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for ColumnNumber

fn term_eq(&self, _: &ColumnNumber) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for ColumnOffset

fn term_eq(&self, _: &ColumnOffset) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for LineIndex

fn term_eq(&self, _: &LineIndex) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for LineNumber

fn term_eq(&self, _: &LineNumber) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N> BoundTerm<N> for LineOffset

fn term_eq(&self, _: &LineOffset) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N, T> BoundTerm<N> for Span<T>

fn term_eq(&self, _: &Span<T>) -> bool

fn close_term(&mut self, _: ScopeState, _: &[Binder<N>])

fn open_term(&mut self, _: ScopeState, _: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N, T> BoundTerm<N> for Option<T> where     T: BoundTerm<N>,

fn term_eq(&self, other: &Option<T>) -> bool

fn close_term(&mut self, state: ScopeState, binders: &[Binder<N>])

fn open_term(&mut self, state: ScopeState, binders: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N, T> BoundTerm<N> for Box<T> where     T: BoundTerm<N>,

fn term_eq(&self, other: &Box<T>) -> bool

fn close_term(&mut self, state: ScopeState, binders: &[Binder<N>])

fn open_term(&mut self, state: ScopeState, binders: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N, T> BoundTerm<N> for Rc<T> where     T: BoundTerm<N> + Clone,

fn term_eq(&self, other: &Rc<T>) -> bool

fn close_term(&mut self, state: ScopeState, binders: &[Binder<N>])

fn open_term(&mut self, state: ScopeState, binders: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N, T> BoundTerm<N> for Arc<T> where     T: BoundTerm<N> + Clone,

fn term_eq(&self, other: &Arc<T>) -> bool

fn close_term(&mut self, state: ScopeState, binders: &[Binder<N>])

fn open_term(&mut self, state: ScopeState, binders: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N, T1, T2> BoundTerm<N> for (T1, T2) where     T1: BoundTerm<N>,     T2: BoundTerm<N>,

fn term_eq(&self, other: &(T1, T2)) -> bool

fn close_term(&mut self, state: ScopeState, binders: &[Binder<N>])

fn open_term(&mut self, state: ScopeState, binders: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N, T1, T2, T3> BoundTerm<N> for (T1, T2, T3) where     T1: BoundTerm<N>,     T2: BoundTerm<N>,     T3: BoundTerm<N>,

fn term_eq(&self, other: &(T1, T2, T3)) -> bool

fn close_term(&mut self, state: ScopeState, binders: &[Binder<N>])

fn open_term(&mut self, state: ScopeState, binders: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N, T> BoundTerm<N> for [T] where     T: BoundTerm<N>,

fn term_eq(&self, other: &[T]) -> bool

fn close_term(&mut self, state: ScopeState, binders: &[Binder<N>])

fn open_term(&mut self, state: ScopeState, binders: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

impl<N, T> BoundTerm<N> for Vec<T> where     T: BoundTerm<N>,

fn term_eq(&self, other: &Vec<T>) -> bool

fn close_term(&mut self, state: ScopeState, binders: &[Binder<N>])

fn open_term(&mut self, state: ScopeState, binders: &[Binder<N>])

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

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

fn free_vars(&self) -> HashSet<FreeVar<N>> where     N: Eq + Hash + Clone,

Implementors

• impl<N: PartialEq> BoundTerm<N> for FreeVar<N>

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

• impl<N, T> BoundTerm<N> for Ignore<T>

• impl<N, P, T> BoundTerm<N> for Scope<P, T> where     P: BoundPattern<N>,     T: BoundTerm<N>,