Trait chalk_ir::fold::Fold

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

Applies the given Folder to a value, producing a folded result of type Self::Result. The result type is typically the same as the source type, 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).

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).

Required methods

fn fold_with<'i>(
    self,
    folder: &mut dyn Folder<'i, I>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: '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.

Implementations on Foreign Types

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

type Result = Vec<T::Result>

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

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

type Result = Box<T::Result>

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

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

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

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

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

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

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

impl<A: Fold<I>, B: Fold<I>, C: Fold<I>, D: Fold<I>, I: Interner> Fold<I> 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>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i, 

impl<A: Fold<I>, B: Fold<I>, C: Fold<I>, D: Fold<I>, E: Fold<I>, I: Interner> Fold<I> 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>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i, 

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

type Result = Option<T::Result>

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

impl<I: Interner> Fold<I> for bool

type Result = Self

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

impl<I: Interner> Fold<I> for usize

type Result = Self

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

impl<I: Interner> Fold<I> for ()

type Result = Self

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

impl<I: Interner> Fold<I> for PhantomData<I>

type Result = PhantomData<I>

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

Implementors

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

type Result = InEnvironment<_U>

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

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

type Result = Canonical<T::Result>

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

impl<I: Interner> Fold<I> for AliasTy<I>

type Result = AliasTy<I>

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

impl<I: Interner> Fold<I> for ClausePriority

type Result = Self

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

impl<I: Interner> Fold<I> for Constraint<I>

type Result = Constraint<I>

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

impl<I: Interner> Fold<I> for DomainGoal<I>

type Result = DomainGoal<I>

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

impl<I: Interner> Fold<I> for FloatTy

type Result = Self

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

impl<I: Interner> Fold<I> for FromEnv<I>

type Result = FromEnv<I>

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

impl<I: Interner> Fold<I> for GenericArgData<I>

type Result = GenericArgData<I>

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

impl<I: Interner> Fold<I> for GoalData<I>

type Result = GoalData<I>

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

impl<I: Interner> Fold<I> for IntTy

type Result = Self

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

impl<I: Interner> Fold<I> for Mutability

type Result = Self

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

impl<I: Interner> Fold<I> for QuantifierKind

type Result = Self

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

impl<I: Interner> Fold<I> for Safety

type Result = Self

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

impl<I: Interner> Fold<I> for Scalar

type Result = Self

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

impl<I: Interner> Fold<I> for UintTy

type Result = Self

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

impl<I: Interner> Fold<I> for WellFormed<I>

type Result = WellFormed<I>

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

impl<I: Interner> Fold<I> for WhereClause<I>

type Result = WhereClause<I>

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

impl<I: Interner> Fold<I> for AdtId<I>

type Result = AdtId<I>

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

impl<I: Interner> Fold<I> for AliasEq<I>

type Result = AliasEq<I>

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

impl<I: Interner> Fold<I> for AnswerSubst<I>

type Result = AnswerSubst<I>

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

impl<I: Interner> Fold<I> for AssocTypeId<I>

type Result = AssocTypeId<I>

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

impl<I: Interner> Fold<I> for ClosureId<I>

type Result = ClosureId<I>

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

impl<I: Interner> Fold<I> 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<I>

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

impl<I: Interner> Fold<I> for ConstrainedSubst<I>

type Result = ConstrainedSubst<I>

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

impl<I: Interner> Fold<I> for Constraints<I>

type Result = Constraints<I>

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

impl<I: Interner> Fold<I> for DebruijnIndex

type Result = Self

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

impl<I: Interner> Fold<I> for DynTy<I>

type Result = DynTy<I>

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

impl<I: Interner> Fold<I> for Environment<I>

type Result = Environment<I>

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

impl<I: Interner> Fold<I> for EqGoal<I>

type Result = EqGoal<I>

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

impl<I: Interner> Fold<I> for FnDefId<I>

type Result = FnDefId<I>

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

impl<I: Interner> Fold<I> for FnPointer<I>

type Result = FnPointer<I>

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

impl<I: Interner> Fold<I> for FnSubst<I>

type Result = FnSubst<I>

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

impl<I: Interner> Fold<I> for ForeignDefId<I>

type Result = ForeignDefId<I>

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

impl<I: Interner> Fold<I> for GeneratorId<I>

type Result = GeneratorId<I>

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

impl<I: Interner> Fold<I> for GenericArg<I>

type Result = GenericArg<I>

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

impl<I: Interner> Fold<I> for Goal<I>

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

type Result = Goal<I>

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

impl<I: Interner> Fold<I> for Goals<I>

type Result = Goals<I>

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

impl<I: Interner> Fold<I> for ImplId<I>

type Result = ImplId<I>

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

impl<I: Interner> Fold<I> 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<I>

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

impl<I: Interner> Fold<I> for LifetimeOutlives<I>

type Result = LifetimeOutlives<I>

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

impl<I: Interner> Fold<I> for Normalize<I>

type Result = Normalize<I>

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

impl<I: Interner> Fold<I> for OpaqueTy<I>

type Result = OpaqueTy<I>

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

impl<I: Interner> Fold<I> for OpaqueTyId<I>

type Result = OpaqueTyId<I>

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

impl<I: Interner> Fold<I> for PlaceholderIndex

type Result = Self

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

impl<I: Interner> Fold<I> 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<I>

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

impl<I: Interner> Fold<I> for ProgramClauseData<I>

type Result = ProgramClauseData<I>

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

impl<I: Interner> Fold<I> for ProgramClauseImplication<I>

type Result = ProgramClauseImplication<I>

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

impl<I: Interner> Fold<I> for ProgramClauses<I>

type Result = ProgramClauses<I>

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

impl<I: Interner> Fold<I> for ProjectionTy<I>

type Result = ProjectionTy<I>

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

impl<I: Interner> Fold<I> for QuantifiedWhereClauses<I>

type Result = QuantifiedWhereClauses<I>

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

impl<I: Interner> Fold<I> for Substitution<I>

type Result = Substitution<I>

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

impl<I: Interner> Fold<I> for SubtypeGoal<I>

type Result = SubtypeGoal<I>

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

impl<I: Interner> Fold<I> for TraitId<I>

type Result = TraitId<I>

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

impl<I: Interner> Fold<I> for TraitRef<I>

type Result = TraitRef<I>

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

impl<I: Interner> Fold<I> 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<I>

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

impl<I: Interner> Fold<I> for TypeOutlives<I>

type Result = TypeOutlives<I>

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

impl<I: Interner> Fold<I> for UniverseIndex

type Result = Self

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

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

type Result = Binders<T::Result>

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