# 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

source§### impl<I: Interner> TypeFoldable<I> for Variance

### impl<I: Interner> TypeFoldable<I> for Variance

source§#### fn try_fold_with<F: FallibleTypeFolder<I>>(
self,
_: &mut F,
) -> Result<Self, F::Error>

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

source§#### fn fold_with<F: TypeFolder<I>>(self, _: &mut F) -> Self

#### fn fold_with<F: TypeFolder<I>>(self, _: &mut F) -> Self

`try_fold_with`

for use with infallible
folders. Do not override this method, to ensure coherence with
`try_fold_with`

.source§### impl<I: Interner> TypeVisitable<I> for Variance

### impl<I: Interner> TypeVisitable<I> for Variance

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

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

### 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> IntoEither for T

### impl<T> IntoEither for T

source§#### fn into_either(self, into_left: bool) -> Either<Self, Self>

#### fn into_either(self, into_left: bool) -> Either<Self, Self>

`self`

into a `Left`

variant of `Either<Self, Self>`

if `into_left`

is `true`

.
Converts `self`

into a `Right`

variant of `Either<Self, Self>`

otherwise. Read moresource§#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>

#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>

`self`

into a `Left`

variant of `Either<Self, Self>`

if `into_left(&self)`

returns `true`

.
Converts `self`

into a `Right`

variant of `Either<Self, Self>`

otherwise. Read moresource§### impl<T> Pointable for T

### impl<T> Pointable for T

source§### impl<I, T> TypeVisitableExt<I> for Twhere
I: Interner,
T: TypeVisitable<I>,

### impl<I, T> TypeVisitableExt<I> for Twhere
I: Interner,
T: TypeVisitable<I>,

#### fn has_type_flags(&self, flags: TypeFlags) -> bool

source§#### fn has_vars_bound_at_or_above(&self, binder: DebruijnIndex) -> bool

#### fn has_vars_bound_at_or_above(&self, binder: DebruijnIndex) -> bool

`true`

if `self`

has any late-bound regions that are either
bound by `binder`

or bound by some binder outside of `binder`

.
If `binder`

is `ty::INNERMOST`

, this indicates whether
there are any late-bound regions that appear free.#### fn error_reported(&self) -> Result<(), <I as Interner>::ErrorGuaranteed>

source§#### fn has_vars_bound_above(&self, binder: DebruijnIndex) -> bool

#### fn has_vars_bound_above(&self, binder: DebruijnIndex) -> bool

`true`

if this type has any regions that escape `binder`

(and
hence are not bound by it).source§#### fn has_escaping_bound_vars(&self) -> bool

#### fn has_escaping_bound_vars(&self) -> bool

`true`

if this type has regions that are not a part of the type.
For example, `for<'a> fn(&'a i32)`

return `false`

, while `fn(&'a i32)`

would return `true`

. The latter can occur when traversing through the
former. Read more#### fn has_aliases(&self) -> bool

#### fn has_inherent_projections(&self) -> bool

#### fn has_opaque_types(&self) -> bool

#### fn has_coroutines(&self) -> bool

#### fn references_error(&self) -> bool

#### fn has_non_region_param(&self) -> bool

#### fn has_infer_regions(&self) -> bool

#### fn has_infer_types(&self) -> bool

#### fn has_non_region_infer(&self) -> bool

#### fn has_infer(&self) -> bool

#### fn has_placeholders(&self) -> bool

#### fn has_non_region_placeholders(&self) -> bool

#### fn has_param(&self) -> bool

source§#### fn has_free_regions(&self) -> bool

#### fn has_free_regions(&self) -> bool

#### fn has_erased_regions(&self) -> bool

source§#### fn has_erasable_regions(&self) -> bool

#### fn has_erasable_regions(&self) -> bool

source§#### fn is_global(&self) -> bool

#### fn is_global(&self) -> bool

source§#### fn has_bound_regions(&self) -> bool

#### fn has_bound_regions(&self) -> bool

source§#### fn has_non_region_bound_vars(&self) -> bool

#### fn has_non_region_bound_vars(&self) -> bool

source§#### fn has_bound_vars(&self) -> bool

#### fn has_bound_vars(&self) -> bool

source§#### fn still_further_specializable(&self) -> bool

#### fn still_further_specializable(&self) -> bool

`impl`

specialization.source§### impl<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,

### impl<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,

source§### impl<I, T> UpcastFrom<I, T> for T

### impl<I, T> UpcastFrom<I, T> for T

#### fn upcast_from(from: T, _tcx: I) -> 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