Trait chalk_ir::fold::Fold

pub trait Fold<I: Interner>: Debug {
    type Result;
    pub 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).

Loading content...

Required methods

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

Loading content...

Implementations on Foreign Types

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

type Result = T::Result

pub 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 Vec<T>

type Result = Vec<T::Result>

pub 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>

pub 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 Arc<T>

type Result = Arc<T::Result>

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

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

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

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

pub 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>

pub 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

pub 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

pub 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

pub 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>

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

Loading content...

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>

pub 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>

pub 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>

pub 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

pub 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>

pub 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>

pub 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

pub 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>

pub 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>

pub 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>

pub 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

pub 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

pub 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

pub 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

pub 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

pub 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

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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>

pub 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

pub 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>

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

Loading content...