Struct Opening 

pub struct Opening { /* private fields */ }

An opening substitution is used to map bound variables into free variables. Note that because of the differences in ordering for bound variable indices (inside out) and context variables (left to right, but variables are inserted in outside-in order), Bound(0) gets mapped to Free(0, base + n).

Implementations

impl Opening

pub fn new(is_universal: bool, free_base: u32) -> Self

pub fn next(&mut self)

Trait Implementations

impl<'a> Shiftable<'a> for Opening

type Inner = Opening

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

impl<'a> Substitution<'a> for Opening

type Error = Void

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>>, Void>

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>>, Void>

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>>, Void>

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>