# Enum rustc_middle::ty::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> Decodable<__D> for Variancewhere
__D: SpanDecoder,

### impl<__D> Decodable<__D> for Variancewhere
__D: SpanDecoder,

source§### impl<__E> Encodable<__E> for Variancewhere
__E: SpanEncoder,

### impl<__E> Encodable<__E> for Variancewhere
__E: SpanEncoder,

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<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> RefDecodable<'tcx, D> for Variance

### impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> RefDecodable<'tcx, D> for Variance

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

source§### impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Variance

### impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Variance

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

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

source§### impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for Variance

### impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for Variance

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

#### fn visit_with<F: TypeVisitor<TyCtxt<'tcx>>>(&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<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere
T: Copy,

### impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere
T: Copy,

#### fn allocate_on<'a>(self, arena: &'a Arena<'tcx>) -> &'a mut T

#### fn allocate_from_iter<'a>( arena: &'a Arena<'tcx>, iter: impl IntoIterator<Item = T> ) -> &'a mut [T]

source§### impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere
T: Copy,

### impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere
T: Copy,

#### fn allocate_on<'a>(self, arena: &'a Arena<'tcx>) -> &'a mut T

#### fn allocate_from_iter<'a>( arena: &'a Arena<'tcx>, iter: impl IntoIterator<Item = T> ) -> &'a mut [T]

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<Tcx, T> DepNodeParams<Tcx> for T

### impl<Tcx, T> DepNodeParams<Tcx> for T

#### default fn fingerprint_style() -> FingerprintStyle

source§#### default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint

#### default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint

#### default fn to_debug_str(&self, _: Tcx) -> String

source§#### default fn recover(_: Tcx, _: &DepNode) -> Option<T>

#### default fn recover(_: Tcx, _: &DepNode) -> Option<T>

`DepNode`

,
something which is needed when forcing `DepNode`

s during red-green
evaluation. The query system will only call this method if
`fingerprint_style()`

is not `FingerprintStyle::Opaque`

.
It is always valid to return `None`

here, in which case incremental
compilation will treat the query as having changed instead of forcing it.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> Filterable for T

### impl<T> Filterable for T

source§#### fn filterable(
self,
filter_name: &'static str
) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>

#### fn filterable( self, filter_name: &'static str ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>

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<P> IntoQueryParam<P> for P

### impl<P> IntoQueryParam<P> for P

#### fn into_query_param(self) -> P

source§### impl<'tcx, T> IsSuggestable<'tcx> for T

### impl<'tcx, T> IsSuggestable<'tcx> for T

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

### impl<T> MaybeResult<T> for T

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

### impl<T> Pointable for T

source§### impl<'tcx, T> ToPredicate<'tcx, T> for T

### impl<'tcx, T> ToPredicate<'tcx, T> for T

#### fn to_predicate(self, _tcx: TyCtxt<'tcx>) -> 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<Tcx, T> Value<Tcx> for Twhere
Tcx: DepContext,

### impl<Tcx, T> Value<Tcx> for Twhere
Tcx: DepContext,

#### default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed ) -> 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,

### impl<T> ErasedDestructor for Twhere
T: 'static,

### impl<T> MaybeSendSync for T

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