Enum rustc_infer::infer::canonical::ir::Variance

pub enum Variance {
    Covariant,
    Invariant,
    Contravariant,
    Bivariant,
}

Variants

Covariant

Invariant

Contravariant

Bivariant

Implementations

impl Variance

pub fn xform(self, v: Variance) -> Variance

a.xform(b) combines the variance of a context with the variance of a type with the following meaning. If we are in a context with variance a, and we encounter a type argument in a position with variance b, then a.xform(b) is the new variance with which the argument appears.

Example 1:

*mut Vec<i32>

Here, the “ambient” variance starts as covariant. *mut T is invariant with respect to T, so the variance in which the Vec<i32> appears is Covariant.xform(Invariant), which yields Invariant. Now, the type Vec<T> is covariant with respect to its type argument T, and hence the variance of the i32 here is Invariant.xform(Covariant), which results (again) in Invariant.

Example 2:

fn(*const Vec<i32>, *mut Vec<i32)

The ambient variance is covariant. A fn type is contravariant with respect to its parameters, so the variance within which both pointer types appear is Covariant.xform(Contravariant), or Contravariant. *const T is covariant with respect to T, so the variance within which the first Vec<i32> appears is Contravariant.xform(Covariant) or Contravariant. The same is true for its i32 argument. In the *mut T case, the variance of Vec<i32> is Contravariant.xform(Invariant), and hence the outermost type is Invariant with respect to Vec<i32> (and its i32 argument).

Source: Figure 1 of “Taming the Wildcards: Combining Definition- and Use-Site Variance” published in PLDI’11.

Trait Implementations

impl Clone for Variance

fn clone(&self) -> Variance

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Variance

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

Formats the value using the given formatter.

impl<__D> Decodable<__D> for Variance

where __D: SpanDecoder,

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

impl<__E> Encodable<__E> for Variance

where __E: SpanEncoder,

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

impl EraseType for Variance

type Result = [u8; 1]

impl Hash for Variance

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<__CTX> HashStable<__CTX> for Variance

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

impl ParameterizedOverTcx for Variance

type Value<'tcx> = Variance

impl PartialEq for Variance

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'tcx, D> RefDecodable<'tcx, D> for Variance

where D: TyDecoder<I = TyCtxt<'tcx>>,

fn decode(decoder: &mut D) -> &'tcx Variance

impl<I> TypeFoldable<I> for Variance

where I: Interner,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<Variance, <F as FallibleTypeFolder<I>>::Error>

where F: FallibleTypeFolder<I>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> Variance

where F: TypeFolder<I>,

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> TypeVisitable<I> for Variance

where I: Interner,

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

where F: TypeVisitor<I>,

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

impl Copy for Variance

impl Eq for Variance

impl StructuralPartialEq for Variance

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 1 byte

Size for each variant:

• Covariant: 0 bytes
• Invariant: 0 bytes
• Contravariant: 0 bytes
• Bivariant: 0 bytes