Struct rustc_type_ir::Canonical

pub struct Canonical<I: Interner, V> {
    pub value: V,
    pub max_universe: UniverseIndex,
    pub variables: I::CanonicalVars,
}

A “canonicalized” type V is one where all free inference variables have been rewritten to “canonical vars”. These are numbered starting from 0 in order of first appearance.

Fields

value: V

max_universe: UniverseIndex

variables: I::CanonicalVars

Implementations

impl<I: Interner, V> Canonical<I, V>

pub fn unchecked_map<W>(self, map_op: impl FnOnce(V) -> W) -> Canonical<I, W>

Allows you to map the value of a canonical while keeping the same set of bound variables.

WARNING: This function is very easy to mis-use, hence the name! In particular, the new value W must use all the same type/region variables in precisely the same order as the original! (The ordering is defined by the TypeFoldable implementation of the type in question.)

An example of a correct use of this:

let a: Canonical<I, T> = ...;
let b: Canonical<I, (T,)> = a.unchecked_map(|v| (v, ));

An example of an incorrect use of this:

let a: Canonical<I, T> = ...;
let ty: Ty<I> = ...;
let b: Canonical<I, (T, Ty<I>)> = a.unchecked_map(|v| (v, ty));

pub fn unchecked_rebind<W>(self, value: W) -> Canonical<I, W>

Allows you to map the value of a canonical while keeping the same set of bound variables.

WARNING: This function is very easy to mis-use, hence the name! See the comment of Canonical::unchecked_map for more details.

Trait Implementations

impl<I: Interner, V> Clone for Canonical<I, V>

where V: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I: Interner, V: Debug> Debug for Canonical<I, V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<I: Interner, V, __D: TyDecoder<I = I>> Decodable<__D> for Canonical<I, V>

where V: Decodable<__D>, I::CanonicalVars: Decodable<__D>,

fn decode(__decoder: &mut __D) -> Self

impl<I: Interner, V: Display> Display for Canonical<I, V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<I: Interner, V, __E: TyEncoder<I = I>> Encodable<__E> for Canonical<I, V>

where V: Encodable<__E>, I::CanonicalVars: Encodable<__E>,

fn encode(&self, __encoder: &mut __E)

impl<I: Interner, V> Hash for Canonical<I, V>

where V: Hash,

fn hash<__HIV>(&self, __state: &mut __HIV)

where __HIV: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<I: Interner, V, __CTX> HashStable<__CTX> for Canonical<I, V>

where V: HashStable<__CTX>, I::CanonicalVars: HashStable<__CTX>,

fn hash_stable(&self, __hcx: &mut __CTX, __hasher: &mut StableHasher)

impl<I: Interner, V: PartialEq> PartialEq for Canonical<I, V>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I: Interner, V: TypeFoldable<I>> TypeFoldable<I> for Canonical<I, V>

where I::CanonicalVars: TypeFoldable<I>,

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).

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

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.

impl<I: Interner, V: TypeVisitable<I>> TypeVisitable<I> for Canonical<I, V>

where I::CanonicalVars: TypeVisitable<I>,

fn visit_with<F: TypeVisitor<I>>(&self, folder: &mut F) -> F::Result

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<I: Interner, V: Copy> Copy for Canonical<I, V>

where I::CanonicalVars: Copy,

impl<I: Interner, V: Eq> Eq for Canonical<I, V>

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.