Trait chalk_ir::fold::Fold

pub trait Fold<I: Interner, TI: TargetInterner<I> = I>: Debug {
    type Result;
    fn fold_with<'i>(
        &self, 
        folder: &mut dyn Folder<'i, I, TI>, 
        outer_binder: DebruijnIndex
    ) -> Fallible<Self::Result>
    where
        I: 'i,
        TI: 'i;
}

Applies the given Folder to a value, producing a folded result of type Self::Result. The result is in the interner TI. The result type is typically the same as the source type (modulo interner), but in some cases we convert from borrowed to owned as well (e.g., the folder for &T will fold to a fresh T; well, actually T::Result).

Interners

The Fold trait has two type parameters, I and TI:

• I is the "source interner" that we are folding from
• TI is the "target interner" that we are folding into

Often, both are the same.

Associated Types

type Result

The type of value that will be produced once folding is done. Typically this is Self, unless Self contains borrowed values, in which case owned values are produced (for example, one can fold over a &T value where T: Fold, in which case you get back a T, not a &T).

Loading content...

Required methods

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

Apply the given folder folder to self; binders is the number of binders that are in scope when beginning the folder. Typically binders starts as 0, but is adjusted when we encounter Binders<T> in the IR or other similar constructs.

Loading content...

Implementations on Foreign Types

impl<'a, T: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for &'a T

type Result = T::Result

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<T: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Vec<T>

type Result = Vec<T::Result>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<T: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Box<T>

type Result = Box<T::Result>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<T: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Arc<T>

type Result = Arc<T::Result>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<A: Fold<I, TI>, B: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for (A, B)

type Result = (A::Result, B::Result)

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<A: Fold<I, TI>, B: Fold<I, TI>, C: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for (A, B, C)

type Result = (A::Result, B::Result, C::Result)

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<A: Fold<I, TI>, B: Fold<I, TI>, C: Fold<I, TI>, D: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for (A, B, C, D)

type Result = (A::Result, B::Result, C::Result, D::Result)

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<A: Fold<I, TI>, B: Fold<I, TI>, C: Fold<I, TI>, D: Fold<I, TI>, E: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for (A, B, C, D, E)

type Result = (A::Result, B::Result, C::Result, D::Result, E::Result)

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<T: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Option<T>

type Result = Option<T::Result>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for bool

type Result = Self

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for usize

type Result = Self

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for ()

type Result = Self

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for PhantomData<I>

type Result = PhantomData<TI>

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

Loading content...

Implementors

impl<G: HasInterner, _I, _U, _TI> Fold<_I, _TI> for InEnvironment<G> where
    _I: Interner,
    G: HasInterner<Interner = _I>,
    G: Fold<_I, _TI, Result = _U>,
    _U: HasInterner<Interner = _TI>,
    _TI: TargetInterner<_I>, 

type Result = InEnvironment<_U>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, _I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    _I: 'i,
    _TI: 'i, 

impl<I, T, TI> Fold<I, TI> for Canonical<T> where
    I: Interner,
    T: HasInterner<Interner = I> + Fold<I, TI>,
    <T as Fold<I, TI>>::Result: HasInterner<Interner = TI>,
    TI: TargetInterner<I>, 

type Result = Canonical<T::Result>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for ClausePriority

type Result = Self

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for FloatTy

type Result = Self

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for IntTy

type Result = Self

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Mutability

type Result = Self

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for QuantifierKind

type Result = Self

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Scalar

type Result = Self

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for UintTy

type Result = Self

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for AdtId<I>

type Result = AdtId<TI>

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for AssocTypeId<I>

type Result = AssocTypeId<TI>

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Const<I>

"Folding" a const invokes the fold_const method on the folder; this usually (in turn) invokes super_fold_const to fold the individual parts.

type Result = Const<TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for DebruijnIndex

type Result = Self

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Fn<I>

type Result = Fn<TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for FnDefId<I>

type Result = FnDefId<TI>

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for GenericArg<I>

type Result = GenericArg<TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Goal<I>

Folding a goal invokes the fold_goal callback (which will, by default, invoke super-fold).

type Result = Goal<TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Goals<I>

type Result = Goals<TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for ImplId<I>

type Result = ImplId<TI>

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Lifetime<I>

"Folding" a lifetime invokes the fold_lifetime method on the folder; this usually (in turn) invokes super_fold_lifetime to fold the individual parts.

type Result = Lifetime<TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for OpaqueTyId<I>

type Result = OpaqueTyId<TI>

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for PlaceholderIndex

type Result = Self

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for ProgramClause<I>

Folding a program clause invokes the fold_program_clause callback on the folder (which will, by default, invoke the super_fold_with method on the program clause).

type Result = ProgramClause<TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for ProgramClauses<I>

type Result = ProgramClauses<TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for QuantifiedWhereClauses<I>

type Result = QuantifiedWhereClauses<TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Substitution<I>

type Result = Substitution<TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for TraitId<I>

type Result = TraitId<TI>

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Ty<I>

"Folding" a type invokes the fold_ty method on the folder; this usually (in turn) invokes super_fold_ty to fold the individual parts.

type Result = Ty<TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for UniverseIndex

type Result = Self

fn fold_with<'i>(
    &self,
    _folder: &mut dyn Folder<'i, I, TI>,
    _outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for AliasTy<I> where
    _TI: TargetInterner<I>, 

type Result = AliasTy<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for Constraint<I> where
    _TI: TargetInterner<I>, 

type Result = Constraint<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for DomainGoal<I> where
    _TI: TargetInterner<I>, 

type Result = DomainGoal<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for FromEnv<I> where
    _TI: TargetInterner<I>, 

type Result = FromEnv<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for GenericArgData<I> where
    _TI: TargetInterner<I>, 

type Result = GenericArgData<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for GoalData<I> where
    _TI: TargetInterner<I>, 

type Result = GoalData<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for ProgramClauseData<I> where
    _TI: TargetInterner<I>, 

type Result = ProgramClauseData<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for TypeName<I> where
    _TI: TargetInterner<I>, 

type Result = TypeName<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for WellFormed<I> where
    _TI: TargetInterner<I>, 

type Result = WellFormed<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for WhereClause<I> where
    _TI: TargetInterner<I>, 

type Result = WhereClause<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for AliasEq<I> where
    _TI: TargetInterner<I>, 

type Result = AliasEq<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for AnswerSubst<I> where
    _TI: TargetInterner<I>, 

type Result = AnswerSubst<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for ApplicationTy<I> where
    _TI: TargetInterner<I>, 

type Result = ApplicationTy<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for ConstrainedSubst<I> where
    _TI: TargetInterner<I>, 

type Result = ConstrainedSubst<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for DynTy<I> where
    _TI: TargetInterner<I>, 

type Result = DynTy<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for Environment<I> where
    _TI: TargetInterner<I>, 

type Result = Environment<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for EqGoal<I> where
    _TI: TargetInterner<I>, 

type Result = EqGoal<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for LifetimeOutlives<I> where
    _TI: TargetInterner<I>, 

type Result = LifetimeOutlives<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for Normalize<I> where
    _TI: TargetInterner<I>, 

type Result = Normalize<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for OpaqueTy<I> where
    _TI: TargetInterner<I>, 

type Result = OpaqueTy<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for ProgramClauseImplication<I> where
    _TI: TargetInterner<I>, 

type Result = ProgramClauseImplication<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for ProjectionTy<I> where
    _TI: TargetInterner<I>, 

type Result = ProjectionTy<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<I: Interner, _TI> Fold<I, _TI> for TraitRef<I> where
    _TI: TargetInterner<I>, 

type Result = TraitRef<_TI>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, _TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    _TI: 'i, 

impl<T, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Binders<T> where
    T: HasInterner<Interner = I> + Fold<I, TI>,
    <T as Fold<I, TI>>::Result: HasInterner<Interner = TI>,
    I: Interner, 

type Result = Binders<T::Result>

fn fold_with<'i>(
    &self,
    folder: &mut dyn Folder<'i, I, TI>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i,
    TI: 'i, 

Loading content...