Trait TypeFoldable 

pub trait TypeFoldable<I: Interner>: TypeVisitable<I> + Clone {
    // Required methods
    fn try_fold_with<F: FallibleTypeFolder<I>>(
        self,
        folder: &mut F,
    ) -> Result<Self, F::Error>;
    fn fold_with<F: TypeFolder<I>>(self, folder: &mut F) -> Self;
}

This trait is implemented for every type that can be folded, providing the skeleton of the traversal.

To implement this conveniently, use the derive macro located in rustc_macros.

This trait is a sub-trait of TypeVisitable. This is because many TypeFolder instances use the methods in TypeVisitableExt while folding, which means in practice almost every foldable type needs to also be visitable. (However, there are some types that are visitable without being foldable.)

Required Methods

fn try_fold_with<F: FallibleTypeFolder<I>>( self, folder: &mut F, ) -> Result<Self, F::Error>

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

For most types, this just traverses the value, calling try_fold_with on each field/element.

For types of interest (such as Ty), the implementation of this method calls a folder method specifically for that type (such as F::try_fold_ty). This is where control transfers from TypeFoldable to FallibleTypeFolder.

fn fold_with<F: TypeFolder<I>>(self, folder: &mut F) -> Self

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

For most types, this just traverses the value, calling fold_with on each field/element.

For types of interest (such as Ty), the implementation of this method calls a folder method specifically for that type (such as F::fold_ty). This is where control transfers from TypeFoldable to TypeFolder.

Same as TypeFoldable::try_fold_with, but not fallible. Make sure to keep the behavior in sync across functions.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

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

fn try_fold_with<F: FallibleTypeFolder<I>>( self, folder: &mut F, ) -> Result<(A, B, C), F::Error>

fn fold_with<F: TypeFolder<I>>(self, folder: &mut F) -> Self

impl<I: Interner, T: TypeFoldable<I>, E: TypeFoldable<I>> TypeFoldable<I> for Result<T, E>

fn try_fold_with<F: FallibleTypeFolder<I>>( self, folder: &mut F, ) -> Result<Self, F::Error>

fn fold_with<F: TypeFolder<I>>(self, folder: &mut F) -> Self

impl<I: Interner, T: TypeFoldable<I>, Ix: Idx> TypeFoldable<I> for IndexVec<Ix, T>

fn try_fold_with<F: FallibleTypeFolder<I>>( self, folder: &mut F, ) -> Result<Self, F::Error>

fn fold_with<F: TypeFolder<I>>(self, folder: &mut F) -> Self

impl<I: Interner, T: TypeFoldable<I>, U: TypeFoldable<I>> TypeFoldable<I> for (T, U)

fn try_fold_with<F: FallibleTypeFolder<I>>( self, folder: &mut F, ) -> Result<(T, U), F::Error>

fn fold_with<F: TypeFolder<I>>(self, folder: &mut F) -> Self

impl<I: Interner, T: TypeFoldable<I>> TypeFoldable<I> for Arc<T>

fn try_fold_with<F: FallibleTypeFolder<I>>( self, folder: &mut F, ) -> Result<Self, F::Error>

fn fold_with<F: TypeFolder<I>>(self, folder: &mut F) -> Self

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

fn try_fold_with<F: FallibleTypeFolder<I>>( self, folder: &mut F, ) -> Result<Self, F::Error>

fn fold_with<F: TypeFolder<I>>(self, folder: &mut F) -> Self

impl<I: Interner, T: TypeFoldable<I>> TypeFoldable<I> for Box<[T]>

fn try_fold_with<F: FallibleTypeFolder<I>>( self, folder: &mut F, ) -> Result<Self, F::Error>

fn fold_with<F: TypeFolder<I>>(self, folder: &mut F) -> Self

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

fn try_fold_with<F: FallibleTypeFolder<I>>( self, folder: &mut F, ) -> Result<Self, F::Error>

fn fold_with<F: TypeFolder<I>>(self, folder: &mut F) -> Self

impl<I: Interner, T: TypeFoldable<I>> TypeFoldable<I> for ThinVec<T>

fn try_fold_with<F: FallibleTypeFolder<I>>( self, folder: &mut F, ) -> Result<Self, F::Error>

fn fold_with<F: TypeFolder<I>>(self, folder: &mut F) -> Self

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

fn try_fold_with<F: FallibleTypeFolder<I>>( self, folder: &mut F, ) -> Result<Self, F::Error>

fn fold_with<F: TypeFolder<I>>(self, folder: &mut F) -> Self

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

fn try_fold_with<F: FallibleTypeFolder<I>>( self, _: &mut F, ) -> Result<Self, F::Error>

fn fold_with<F: TypeFolder<I>>(self, _: &mut F) -> Self

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

fn try_fold_with<F: FallibleTypeFolder<I>>( self, _: &mut F, ) -> Result<Self, F::Error>

fn fold_with<F: TypeFolder<I>>(self, _: &mut F) -> Self

impl<I: Interner> TypeFoldable<I> for u16

fn try_fold_with<F: FallibleTypeFolder<I>>( self, _: &mut F, ) -> Result<Self, F::Error>

fn fold_with<F: TypeFolder<I>>(self, _: &mut F) -> Self

impl<I: Interner> TypeFoldable<I> for u32

fn try_fold_with<F: FallibleTypeFolder<I>>( self, _: &mut F, ) -> Result<Self, F::Error>

fn fold_with<F: TypeFolder<I>>(self, _: &mut F) -> Self

impl<I: Interner> TypeFoldable<I> for u64

fn try_fold_with<F: FallibleTypeFolder<I>>( self, _: &mut F, ) -> Result<Self, F::Error>

fn fold_with<F: TypeFolder<I>>(self, _: &mut F) -> Self

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

fn try_fold_with<F: FallibleTypeFolder<I>>( self, _: &mut F, ) -> Result<Self, F::Error>

fn fold_with<F: TypeFolder<I>>(self, _: &mut F) -> Self

Implementors

impl<I, A> TypeFoldable<I> for OutlivesPredicate<I, A>

where I: Interner, A: TypeFoldable<I>, I::Region: TypeFoldable<I>,

impl<I, P> TypeFoldable<I> for Goal<I, P>

where I: Interner, I::ParamEnv: TypeFoldable<I>, P: TypeFoldable<I>,

impl<I, P> TypeFoldable<I> for QueryInput<I, P>

where I: Interner, Goal<I, P>: TypeFoldable<I>, I::PredefinedOpaques: TypeFoldable<I>,

impl<I, T> TypeFoldable<I> for Placeholder<I, T>

where I: Interner, T: TypeFoldable<I>,

impl<I, T> TypeFoldable<I> for State<I, T>

where I: Interner, CanonicalVarValues<I>: TypeFoldable<I>, T: TypeFoldable<I>,

impl<I: Interner, T: TypeFoldable<I>> TypeFoldable<I> for Binder<I, T>

impl<I: Interner, T> !TypeFoldable<I> for EarlyBinder<I, T>

For early binders, you should first call instantiate before using any visitors.

impl<I: Interner> TypeFoldable<I> for AliasRelationDirection

impl<I: Interner> TypeFoldable<I> for BoundConstness

impl<I: Interner> TypeFoldable<I> for BuiltinImplSource

impl<I: Interner> TypeFoldable<I> for Certainty

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

impl<I: Interner> TypeFoldable<I> for GoalSource

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

impl<I: Interner> TypeFoldable<I> for PredicatePolarity

impl<I: Interner> TypeFoldable<I> for rustc_type_ir::region_constraint::RegionConstraint<I>

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

impl<I: Interner> TypeFoldable<I> for Variance

impl<I: Interner> TypeFoldable<I> for VisibleForLeakCheck

impl<I> TypeFoldable<I> for AccessedOpaques<I>

where I: Interner, RerunCondition<I>: TypeFoldable<I>,

impl<I> TypeFoldable<I> for AliasBoundKind

where I: Interner,

impl<I> TypeFoldable<I> for AliasTerm<I>

where I: Interner, I::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for AliasTy<I>

where I: Interner, I::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for BoundVarIndexKind

where I: Interner,

impl<I> TypeFoldable<I> for CanonicalVarValues<I>

where I: Interner, I::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for ClauseKind<I>

where I: Interner, TraitPredicate<I>: TypeFoldable<I>, OutlivesPredicate<I, I::Region>: TypeFoldable<I>, OutlivesPredicate<I, I::Ty>: TypeFoldable<I>, ProjectionPredicate<I>: TypeFoldable<I>, I::Const: TypeFoldable<I>, I::Ty: TypeFoldable<I>, I::Term: TypeFoldable<I>, HostEffectPredicate<I>: TypeFoldable<I>,

impl<I> TypeFoldable<I> for ClosureArgs<I>

where I: Interner, I::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for CoercePredicate<I>

where I: Interner, I::Ty: TypeFoldable<I>,

impl<I> TypeFoldable<I> for CoroutineArgs<I>

where I: Interner, I::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for CoroutineClosureArgs<I>

where I: Interner, I::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for CoroutineClosureSignature<I>

where I: Interner, I::Ty: TypeFoldable<I>,

impl<I> TypeFoldable<I> for CoroutineWitnessTypes<I>

where I: Interner, I::Tys: TypeFoldable<I>, I::RegionAssumptions: TypeFoldable<I>,

impl<I> TypeFoldable<I> for ExistentialPredicate<I>

where I: Interner, ExistentialTraitRef<I>: TypeFoldable<I>, ExistentialProjection<I>: TypeFoldable<I>, I::TraitId: TypeFoldable<I>,

impl<I> TypeFoldable<I> for ExistentialProjection<I>

where I: Interner, I::TraitAssocTermId: TypeFoldable<I>, I::GenericArgs: TypeFoldable<I>, I::Term: TypeFoldable<I>,

impl<I> TypeFoldable<I> for ExistentialTraitRef<I>

where I: Interner, I::TraitId: TypeFoldable<I>, I::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for ExternalConstraintsData<I>

where I: Interner, ExternalRegionConstraints<I>: TypeFoldable<I>, Vec<(OpaqueTypeKey<I>, I::Ty)>: TypeFoldable<I>, NestedNormalizationGoals<I>: TypeFoldable<I>,

impl<I> TypeFoldable<I> for ExternalRegionConstraints<I>

where I: Interner, Vec<(RegionConstraint<I>, VisibleForLeakCheck)>: TypeFoldable<I>, RegionConstraint<I>: TypeFoldable<I>,

impl<I> TypeFoldable<I> for FnHeader<I>

where I: Interner,

impl<I> TypeFoldable<I> for FnSig<I>

where I: Interner, I::Tys: TypeFoldable<I>,

impl<I> TypeFoldable<I> for FnSigKind<I>

where I: Interner,

impl<I> TypeFoldable<I> for FnSigTys<I>

where I: Interner, I::Tys: TypeFoldable<I>,

impl<I> TypeFoldable<I> for GenSig<I>

where I: Interner, I::Ty: TypeFoldable<I>,

impl<I> TypeFoldable<I> for HostEffectPredicate<I>

where I: Interner, TraitRef<I>: TypeFoldable<I>,

impl<I> TypeFoldable<I> for NestedNormalizationGoals<I>

where I: Interner, Vec<(GoalSource, Goal<I, I::Predicate>)>: TypeFoldable<I>,

impl<I> TypeFoldable<I> for NormalizesTo<I>

where I: Interner, AliasTerm<I>: TypeFoldable<I>, I::Term: TypeFoldable<I>,

impl<I> TypeFoldable<I> for OpaqueTypeKey<I>

where I: Interner, I::LocalOpaqueTyId: TypeFoldable<I>, I::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for PatternKind<I>

where I: Interner, I::Const: TypeFoldable<I>, I::PatList: TypeFoldable<I>,

impl<I> TypeFoldable<I> for PredicateKind<I>

where I: Interner, ClauseKind<I>: TypeFoldable<I>, I::TraitId: TypeFoldable<I>, SubtypePredicate<I>: TypeFoldable<I>, CoercePredicate<I>: TypeFoldable<I>, I::Const: TypeFoldable<I>, NormalizesTo<I>: TypeFoldable<I>, I::Term: TypeFoldable<I>,

impl<I> TypeFoldable<I> for ProbeKind<I>

where I: Interner, QueryResult<I>: TypeFoldable<I>, CandidateSource<I>: TypeFoldable<I>,

impl<I> TypeFoldable<I> for ProjectionPredicate<I>

where I: Interner, AliasTerm<I>: TypeFoldable<I>, I::Term: TypeFoldable<I>,

impl<I> TypeFoldable<I> for rustc_type_ir::RegionConstraint<I>

where I: Interner, OutlivesPredicate<I, I::GenericArg>: TypeFoldable<I>, RegionEqPredicate<I>: TypeFoldable<I>,

impl<I> TypeFoldable<I> for RegionEqPredicate<I>

where I: Interner, I::Region: TypeFoldable<I>,

impl<I> TypeFoldable<I> for RerunCondition<I>

where I: Interner, SmallCopyList<I::LocalDefId>: TypeFoldable<I>,

impl<I> TypeFoldable<I> for Response<I>

where I: Interner, CanonicalVarValues<I>: TypeFoldable<I>, I::ExternalConstraints: TypeFoldable<I>,

impl<I> TypeFoldable<I> for SubtypePredicate<I>

where I: Interner, I::Ty: TypeFoldable<I>,

impl<I> TypeFoldable<I> for TraitPredicate<I>

where I: Interner, TraitRef<I>: TypeFoldable<I>,

impl<I> TypeFoldable<I> for TraitRef<I>

where I: Interner, I::TraitId: TypeFoldable<I>, I::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for TypeAndMut<I>

where I: Interner, I::Ty: TypeFoldable<I>,

impl<I> TypeFoldable<I> for UnevaluatedConst<I>

where I: Interner, I::UnevaluatedConstId: TypeFoldable<I>, I::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for UnsafeBinderInner<I>

where I: Interner, Binder<I, I::Ty>: TypeFoldable<I>,

impl<I> TypeFoldable<I> for ValTreeKind<I>

where I: Interner, I::ScalarInt: TypeFoldable<I>, I::Consts: TypeFoldable<I>,

impl<T, I> TypeFoldable<I> for ExpectedFound<T>

where I: Interner, T: TypeFoldable<I>,

impl<T: Copy + Debug + Hash + Eq, I> TypeFoldable<I> for SmallCopyList<T>

where I: Interner, [T; 1]: TypeFoldable<I>, [T; 2]: TypeFoldable<I>, [T; 3]: TypeFoldable<I>,