What Is Variance in Rust Lifetimes?

Variance in Rust lifetimes defines how generic types relate to their lifetime parameters, allowing the compiler to safely substitute longer lifetimes for shorter ones.

Variance in Rust lifetimes determines how the compiler treats subtyping relationships between generic types based on their lifetime parameters. It dictates whether a type with a longer lifetime can be used where a shorter lifetime is expected (covariant), the opposite (contravariant), or neither (invariant). The compiler automatically calculates this for your types, but you can inspect the result using the #[rustc_dump_variances] attribute on structs, enums, or functions.

#[rustc_dump_variances]
struct Wrapper<'a> {
    data: &'a i32,
}

Compiling this code will output the variance of the 'a parameter (typically Covariant) to the compiler's log, confirming how the type behaves with respect to lifetime subtyping.

Variance is a rule that tells the compiler if a generic type containing a reference can be safely swapped with another type that has a different reference lifetime. Think of it like a container: if you have a box that holds a reference to a long-lived object, variance determines if you can treat that box as if it holds a reference to a short-lived object. This matters because it allows the compiler to accept more flexible code without needing you to manually write complex lifetime annotations.