Struct Innerize 

pub struct Innerize<'c, 'p, 'a> { /* private fields */ }

An innerize substitution is used to bring an outer type alias inwards through one context.

Implementations

impl<'c, 'p, 'a> Innerize<'c, 'p, 'a>

pub fn new(ctx: &'c Ctx<'p, 'a>, outer_boundary: bool) -> Innerize<'c, 'p, 'a>

Trait Implementations

impl<'c, 'p, 'a> Shiftable<'a> for Innerize<'c, 'p, 'a>

type Inner = Innerize<'c, 'p, 'a>

fn shifted<'d>(&'d self) -> Shifted<'d, Self::Inner>

impl<'c, 'p, 'a> Substitution<'a> for Innerize<'c, 'p, 'a>

type Error = InnerizeError

Some, but not all, substitutions are fallible (i.e. may reveal latent misbehaviour in the type they are being applied to), so any given Substitution can provide its own Substitution::Error type.

fn subst_bvar(&self, _i: u32) -> Result<Option<Defined<'a>>, Self::Error>

Any substitution should define whether a given bound variable should be substituted, and if so with what.

fn subst_evar(&self, o: u32, i: u32) -> Result<Option<Defined<'a>>, Self::Error>

Any substitution should define whether a given existential variable should be substituted, and if so with what.

fn subst_uvar(&self, o: u32, i: u32) -> Result<Option<Defined<'a>>, Self::Error>

Any substitution should define whether a given universal variable should be substituted, and if so with what.

fn record_fields( &self, rfs: &[RecordField<'a>], ) -> Result<Vec<RecordField<'a>>, Self::Error>

fn variant_cases( &self, vcs: &[VariantCase<'a>], ) -> Result<Vec<VariantCase<'a>>, Self::Error>

fn value_option( &self, vt: &Option<Value<'a>>, ) -> Result<Option<Value<'a>>, Self::Error>

fn value(&self, vt: &Value<'a>) -> Result<Value<'a>, Self::Error>

fn param(&self, pt: &Param<'a>) -> Result<Param<'a>, Self::Error>

fn params(&self, pts: &Vec<Param<'a>>) -> Result<Vec<Param<'a>>, Self::Error>

fn result(&self, rt: &Result<'a>) -> Result<Result<'a>, Self::Error>

fn func(&self, ft: &Func<'a>) -> Result<Func<'a>, Self::Error>

fn var(&self, tv: &Tyvar) -> Result<Option<Defined<'a>>, Self::Error>

fn handleable(&self, h: &Handleable) -> Result<Defined<'a>, Self::Error>

fn handleable_(&self, h: &Handleable) -> Result<Handleable, Self::Error>

fn defined(&self, dt: &Defined<'a>) -> Result<Defined<'a>, Self::Error>

fn type_bound(&self, tb: &TypeBound<'a>) -> Result<TypeBound<'a>, Self::Error>

fn bounded_tyvar( &self, btv: &BoundedTyvar<'a>, ) -> Result<BoundedTyvar<'a>, Self::Error>

fn extern_desc( &self, ed: &ExternDesc<'a>, ) -> Result<ExternDesc<'a>, Self::Error>

fn extern_decl( &self, ed: &ExternDecl<'a>, ) -> Result<ExternDecl<'a>, Self::Error>

fn instance(&self, it: &Instance<'a>) -> Result<Instance<'a>, Self::Error>

fn qualified_instance( &self, qit: &QualifiedInstance<'a>, ) -> Result<QualifiedInstance<'a>, Self::Error>

fn component(&self, ct: &Component<'a>) -> Result<Component<'a>, Self::Error>