Enum VariancePosition 

#[repr(u8)]
pub enum VariancePosition {
    Covariant = 0,
    Contravariant = 1,
    Invariant = 2,
}

Position of a type dependency in variance computation.

This determines how the dependency’s variance is transformed before combining:

• Covariant: Use the dependency’s variance as-is
• Contravariant: Flip the dependency’s variance before combining
• Invariant: Converts non-bivariant variance to invariant

From the Rust Reference:

• &'a T is covariant with respect to T → T is in covariant position
• fn(T) -> U is contravariant with respect to T → T is in contravariant position
• fn(T) -> U is covariant with respect to U → U is in covariant position
• &'a mut T is invariant with respect to T → T is in invariant position

Variants

Covariant = 0

Dependency’s variance is used as-is.

Examples: T in &T, T in Box<T>, return type in fn() -> T

Contravariant = 1

Dependency’s variance is flipped before combining.

Examples: argument T in fn(T)

Invariant = 2

The type parameter is in invariant position (per Rustonomicon xform rules).

From the Rustonomicon, &'a mut T is covariant with respect to 'a and invariant with respect to T. When we compute combined variance, any lifetimes inside T are in invariant position.

Transformation (xform):

• Bivariant → Bivariant (T has no lifetimes, nothing to make invariant)
• Covariant/Contravariant/Invariant → Invariant (lifetimes in T become invariant)

This means &'a mut i32 is Covariant (only 'a, which is covariant), while &'a mut &'b U is Invariant ('b is in invariant position).

Examples: T in &mut T, T in Cell<T>, T in UnsafeCell<T>

Trait Implementations

impl Clone for VariancePosition

fn clone(&self) -> VariancePosition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for VariancePosition

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

Formats the value using the given formatter.

impl Hash for VariancePosition

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 PartialEq for VariancePosition

fn eq(&self, other: &VariancePosition) -> 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 Copy for VariancePosition

impl Eq for VariancePosition

impl StructuralPartialEq for VariancePosition