Enum rustc_type_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

Formats the value using the given formatter.

impl<__D: Decoder> Decodable<__D> for Variance

fn decode(__decoder: &mut __D) -> Result<Self, <__D as Decoder>::Error>

impl<__E: Encoder> Encodable<__E> for Variance

fn encode(&self, __encoder: &mut __E) -> Result<(), <__E as Encoder>::Error>

impl Hash for Variance

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

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<CTX> HashStable<CTX> for Variance

fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher)

impl PartialEq<Variance> for Variance

fn eq(&self, other: &Variance) -> 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 !=.

impl Copy 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