Struct rustc_trait_selection::infer::canonical::Canonical

pub struct Canonical<'tcx, V> {
    pub max_universe: UniverseIndex,
    pub variables: &'tcx List<CanonicalVarInfo>,
    pub value: V,
}

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

max_universe: UniverseIndex

variables: &'tcx List<CanonicalVarInfo>

value: V

Implementations

impl<'tcx, R> Canonical<'tcx, QueryResponse<'tcx, R>>

pub fn is_proven(&self) -> bool

pub fn is_ambiguous(&self) -> bool

impl<'tcx, V> Canonical<'tcx, V>

pub fn unchecked_map<W>(self, map_op: impl FnOnce(V) -> W) -> Canonical<'tcx, 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<'_, T> = ...;
let b: Canonical<'_, (T,)> = a.unchecked_map(|v| (v, ));

An example of an incorrect use of this:

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

impl<'tcx> Canonical<'tcx, UserType<'tcx>>

pub fn is_identity(&self) -> bool

Returns true if this represents a substitution of the form [?0, ?1, ?2], i.e., each thing is mapped to a canonical variable with the same index.

Trait Implementations

impl<'tcx, V> Clone for Canonical<'tcx, V> where
    V: Clone, 

fn clone(&self) -> Canonical<'tcx, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx, V> Copy for Canonical<'tcx, V> where
    V: Copy, 

impl<'tcx, V> Debug for Canonical<'tcx, V> where
    V: Debug, 

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

Formats the value using the given formatter.

impl<'tcx, V> Eq for Canonical<'tcx, V> where
    V: Eq, 

impl<'tcx, V> Hash for Canonical<'tcx, V> where
    V: Hash, 

fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<'tcx, V> PartialEq<Canonical<'tcx, V>> for Canonical<'tcx, V> where
    V: PartialEq<V>, 

fn eq(&self, other: &Canonical<'tcx, V>) -> bool

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

fn ne(&self, other: &Canonical<'tcx, V>) -> bool

This method tests for !=.