pub fn canonicalize<T: Fold>(&mut self, value: &T) -> Canonicalized<T::Result> {
        debug!("canonicalize({:#?})", value);
        let mut q = Canonicalizer {
            table: self,
            free_vars: Vec::new(),
            max_universe: UniverseIndex::root(),
        };
        let value = value.fold_with(&mut q, 0).unwrap();
        let free_vars = q.free_vars.clone();
        let max_universe = q.max_universe;

        Canonicalized {
            quantified: Canonical { value, binders: q.into_binders() },
            max_universe,
            free_vars,
        }
    }
/// Given a value `value` with variables in it, replaces those variables
/// with their instantiated values; any variables not yet instantiated are
/// replaced with a small integer index 0..N in order of appearance. The
/// result is a canonicalized representation of `value`.
///
/// Example:
///
///    ?22: Foo<?23>
///
/// would be quantified to
///
///    Canonical { value: `?0: Foo<?1>`, binders: [ui(?22), ui(?23)] }
///
/// where `ui(?22)` and `ui(?23)` are the universe indices of `?22` and
/// `?23` respectively.
///
/// A substitution mapping from the free variables to their re-bound form is
/// also returned.
Given a value `value` with variables in it, replaces those variables
with their instantiated values; any variables not yet instantiated are
replaced with a small integer index 0..N in order of appearance. The
result is a canonicalized representation of `value`.





would be quantified to





A substitution mapping from the free variables to their re-bound form is
also returned.
Given a value ` value ` with variables in it replaces those variables with their instantiated values ; any variables not yet instantiated are replaced with a small integer index 0 .. N in order of appearance . The result is a canonicalized representation of ` value ` . would be quantified to A substitution mapping from the free variables to their re - bound form is also returned .
pub fn canonicalize<T: Fold>(&mut self, value: &T) -> Canonicalized<T::Result> {
        debug!("canonicalize({:#?})", value);
        let mut q = Canonicalizer {
            table: self,
            free_vars: Vec::new(),
            max_universe: UniverseIndex::root(),
        };
        let value = value.fold_with(&mut q, 0).unwrap();
        let free_vars = q.free_vars.clone();
        let max_universe = q.max_universe;
        Canonicalized {
            quantified: Canonical { value, binders: q.into_binders() },
            max_universe,
            free_vars,
        }
    }
pub fn canonicalize < T : Fold > ( & mut self , value : & T ) -> Canonicalized < T :: Result > { debug ! ( " " value ) ; let mut q = Canonicalizer { table : self , free_vars : Vec :: new ( ) , max_universe : UniverseIndex :: root ( ) , } ; let value = value . fold_with ( & mut q , 0 ) . unwrap ( ) ; let free_vars = q . free_vars . clone ( ) ; let max_universe = q . max_universe ; Canonicalized { quantified : Canonical { value , binders : q . into_binders ( ) } , max_universe , free_vars , } }
Given a value `value` with variables in it, replaces those variables
with their instantiated values; any variables not yet instantiated are
replaced with a small integer index 0..N in order of appearance.
Given a value ` value ` with variables in it replaces those variables with their instantiated values ; any variables not yet instantiated are replaced with a small integer index 0 .. N in order of appearance .
&mut self
value
&T