Struct NormalizationFolder 

pub struct NormalizationFolder<'a, Infcx, I, F>
where
    Infcx: InferCtxtLike<Interner = I>,
    I: Interner,
{
    infcx: &'a Infcx,
    universes: Vec<Option<UniverseIndex>>,
    stalled_goals: Vec<Goal<I, I::Predicate>>,
    normalize: F,
}

This folder normalizes value and collects ambiguous goals.

Note that for ambiguous alias which contains escaping bound vars, we just return the original alias and don’t collect the ambiguous goal.

Fields

infcx: &'a Infcx

universes: Vec<Option<UniverseIndex>>

stalled_goals: Vec<Goal<I, I::Predicate>>

normalize: F

Implementations

impl<'a, Infcx, I, F> NormalizationFolder<'a, Infcx, I, F>

where Infcx: InferCtxtLike<Interner = I>, I: Interner, F: FnMut(I::Term) -> Result<(I::Term, Option<Goal<I, I::Predicate>>), NoSolution>,

pub fn new( infcx: &'a Infcx, universes: Vec<Option<UniverseIndex>>, stalled_goals: Vec<Goal<I, I::Predicate>>, normalize: F, ) -> Self

pub fn stalled_goals(self) -> Vec<Goal<I, I::Predicate>>

fn normalize_alias_term( &mut self, alias_term: I::Term, has_escaping: HasEscapingBoundVars, ) -> Result<I::Term, NoSolution>

Trait Implementations

impl<'a, Infcx, I, F> FallibleTypeFolder<I> for NormalizationFolder<'a, Infcx, I, F>

where Infcx: InferCtxtLike<Interner = I>, I: Interner, F: FnMut(I::Term) -> Result<(I::Term, Option<Goal<I, I::Predicate>>), NoSolution>,

type Error = NoSolution

fn cx(&self) -> I

fn try_fold_binder<T: TypeFoldable<I>>( &mut self, t: Binder<I, T>, ) -> Result<Binder<I, T>, Self::Error>

fn try_fold_ty(&mut self, ty: I::Ty) -> Result<I::Ty, Self::Error>

fn try_fold_const(&mut self, ct: I::Const) -> Result<I::Const, Self::Error>

fn try_fold_region( &mut self, r: <I as Interner>::Region, ) -> Result<<I as Interner>::Region, Self::Error>

fn try_fold_predicate( &mut self, p: <I as Interner>::Predicate, ) -> Result<<I as Interner>::Predicate, Self::Error>

fn try_fold_clauses( &mut self, c: <I as Interner>::Clauses, ) -> Result<<I as Interner>::Clauses, Self::Error>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.