Trait moniker::BoundTerm

pub trait BoundTerm<N: Clone + PartialEq> {
    fn term_eq(&self, other: &Self) -> bool;
    fn close_term(&mut self, state: ScopeState, on_free: &impl OnFreeFn<N>);
    fn open_term(&mut self, state: ScopeState, on_bound: &impl OnBoundFn<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 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

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: Clone + PartialEq> BoundTerm<N> for ByteIndex

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<N: Clone + PartialEq, T> BoundTerm<N> for Span<T>

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

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

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

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

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

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

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

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

fn open_term(&mut self, state: ScopeState, on_bound: &impl OnBoundFn<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>))

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

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

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

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

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

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

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

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

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

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

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

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

impl<N: Clone + PartialEq> BoundTerm<N> for ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn open_term(&mut self, state: ScopeState, on_bound: &impl OnBoundFn<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>))

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

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

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

fn open_term(&mut self, state: ScopeState, on_bound: &impl OnBoundFn<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>))

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

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

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

fn open_term(&mut self, state: ScopeState, on_bound: &impl OnBoundFn<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>))

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

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

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

fn open_term(&mut self, state: ScopeState, on_bound: &impl OnBoundFn<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>))

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

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

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

fn open_term(&mut self, state: ScopeState, on_bound: &impl OnBoundFn<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>))

impl<N, T1, T2, T3> BoundTerm<N> for (T1, T2, T3)where
    N: Clone + PartialEq,
    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, on_free: &impl OnFreeFn<N>)

fn open_term(&mut self, state: ScopeState, on_bound: &impl OnBoundFn<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>))

impl<N, T1, T2, T3, T4> BoundTerm<N> for (T1, T2, T3, T4)where
    N: Clone + PartialEq,
    T1: BoundTerm<N>,
    T2: BoundTerm<N>,
    T3: BoundTerm<N>,
    T4: BoundTerm<N>,

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

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

fn open_term(&mut self, state: ScopeState, on_bound: &impl OnBoundFn<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>))

impl<N, T1, T2, T3, T4, T5> BoundTerm<N> for (T1, T2, T3, T4, T5)where
    N: Clone + PartialEq,
    T1: BoundTerm<N>,
    T2: BoundTerm<N>,
    T3: BoundTerm<N>,
    T4: BoundTerm<N>,
    T5: BoundTerm<N>,

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

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

fn open_term(&mut self, state: ScopeState, on_bound: &impl OnBoundFn<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>))

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

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

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

fn open_term(&mut self, state: ScopeState, on_bound: &impl OnBoundFn<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>))

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

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

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

fn open_term(&mut self, state: ScopeState, on_bound: &impl OnBoundFn<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>))

Implementors

impl<N, P, T> BoundTerm<N> for Scope<P, T>where
    N: Clone + PartialEq,
    P: BoundPattern<N>,
    T: BoundTerm<N>,

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

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

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