Trait TypeFolder

pub trait TypeFolder<I: Interner>: Sized {
    // Required method
    fn cx(&self) -> I;

    // Provided methods
    fn fold_binder<T>(&mut self, t: Binder<I, T>) -> Binder<I, T>
       where T: TypeFoldable<I> { ... }
    fn fold_ty(&mut self, t: I::Ty) -> I::Ty { ... }
    fn fold_region(&mut self, r: I::Region) -> I::Region { ... }
    fn fold_const(&mut self, c: I::Const) -> I::Const { ... }
    fn fold_predicate(&mut self, p: I::Predicate) -> I::Predicate { ... }
}

This trait is implemented for every infallible folding traversal. There is a fold method defined for every type of interest. Each such method has a default that does an “identity” fold. Implementations of these methods often fall back to a super_fold_with method if the primary argument doesn’t satisfy a particular condition.

A blanket implementation of FallibleTypeFolder will defer to the infallible methods of this trait to ensure that the two APIs are coherent.

Required Methods

fn cx(&self) -> I

Provided Methods

fn fold_binder<T>(&mut self, t: Binder<I, T>) -> Binder<I, T>

where T: TypeFoldable<I>,

fn fold_ty(&mut self, t: I::Ty) -> I::Ty

fn fold_region(&mut self, r: I::Region) -> I::Region

fn fold_const(&mut self, c: I::Const) -> I::Const

fn fold_predicate(&mut self, p: I::Predicate) -> I::Predicate

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'a, I: Interner> TypeFolder<I> for ArgFolder<'a, I>

impl<I, F> TypeFolder<I> for RegionFolder<I, F>

where I: Interner, F: FnMut(I::Region, DebruijnIndex) -> I::Region,

impl<I: Interner> TypeFolder<I> for Shifter<I>

impl<I: Interner> TypeFolder<I> for FoldEscapingRegions<I>