# Enum rustc_type_ir::Variance

source · ```
pub enum Variance {
Covariant,
Invariant,
Contravariant,
Bivariant,
}
```

## Variants§

## Implementations§

source§### impl Variance

### impl Variance

source#### pub fn xform(self, v: Variance) -> 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§

source§### impl<__D: SpanDecoder> Decodable<__D> for Variance

### impl<__D: SpanDecoder> Decodable<__D> for Variance

source§### impl<__E: SpanEncoder> Encodable<__E> for Variance

### impl<__E: SpanEncoder> Encodable<__E> for Variance

source§### impl<__CTX> HashStable<__CTX> for Variance

### impl<__CTX> HashStable<__CTX> for Variance

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

source§### impl PartialEq for Variance

### impl PartialEq for Variance

### impl Copy for Variance

### impl Eq for Variance

### impl StructuralPartialEq for Variance

## Auto Trait Implementations§

### impl DynSend for Variance

### impl DynSync for Variance

### impl Freeze for Variance

### impl RefUnwindSafe for Variance

### impl Send for Variance

### impl Sync for Variance

### impl Unpin for Variance

### impl UnwindSafe for Variance

## Blanket Implementations§

source§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

source§#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

source§### impl<T, R> CollectAndApply<T, R> for T

### impl<T, R> CollectAndApply<T, R> for T

source§### impl<Q, K> Equivalent<K> for Q

### impl<Q, K> Equivalent<K> for Q

source§### impl<Q, K> Equivalent<K> for Q

### impl<Q, K> Equivalent<K> for Q

source§### impl<Q, K> Equivalent<K> for Q

### impl<Q, K> Equivalent<K> for Q

source§#### fn equivalent(&self, key: &K) -> bool

#### fn equivalent(&self, key: &K) -> bool

`key`

and return `true`

if they are equal.source§### impl<T> Instrument for T

### impl<T> Instrument for T

source§#### fn instrument(self, span: Span) -> Instrumented<Self>

#### fn instrument(self, span: Span) -> Instrumented<Self>

source§#### fn in_current_span(self) -> Instrumented<Self>

#### fn in_current_span(self) -> Instrumented<Self>

source§### impl<T> Pointable for T

### impl<T> Pointable for T

source§### impl<T> WithSubscriber for T

### impl<T> WithSubscriber for T

source§#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>

source§#### fn with_current_subscriber(self) -> WithDispatch<Self>

#### fn with_current_subscriber(self) -> WithDispatch<Self>

### impl<'a, T> Captures<'a> for Twhere
T: ?Sized,

## 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