FerrousPath

Nivel 4 · Experto· Lección 2 de 9 · 30 min

Subtipado y varianza

Los lifetimes como relación de subtipado, covarianza, contravarianza e invarianza, y por qué &mut T debe ser invariante.

La varianza es la parte del sistema de tipos que decide cuándo un tipo genérico puede usarse en lugar de otro. Has dependido de ella en cada programa que pasa un &'static str donde se espera un &'a str. Cuando escribes código unsafe con punteros crudos, elegirla pasa a ser responsabilidad tuya.

Subtipado de lifetimes

Rust no tiene herencia, pero sí tiene subtipado: sobre los lifetimes. 'long: 'short se lee «'long sobrevive a 'short», y hace de 'long un subtipo de 'short: todo lo que es válido durante la región más larga lo es sin duda durante la más corta.

fn shorter<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.len() <= b.len() { a } else { b }
}

fn main() {
    let forever: &'static str = "static text";
    let local = String::from("local");
    // `forever` es &'static str, pero se acepta como &'a str para el 'a más corto de `local`.
    println!("{}", shorter(forever, &local));
}

'static sobrevive a todo, así que es un subtipo de cualquier lifetime.

Varianza

Dado un constructor de tipos F<T> y siendo Sub un subtipo de Super:

  • F es covariante si F<Sub> es un subtipo de F<Super>: la relación se mantiene.
  • F es contravariante si F<Super> es un subtipo de F<Sub>: la relación se invierte.
  • F es invariante si no se cumple ninguna de las dos: los tipos deben coincidir exactamente.
Tipo en 'a en T
&'a T covariante covariante
&'a mut T covariante invariante
Box<T>, Vec<T>, Option<T> covariante
*const T, NonNull<T> covariante
*mut T invariante
Cell<T>, RefCell<T>, UnsafeCell<T>, Mutex<T> invariante
fn(T) -> U contravariante en T, covariante en U
PhantomData<T> covariante
dyn Trait<T> + 'a covariante invariante

El patrón: el acceso de solo lectura es covariante; todo lo que te deje escribir es invariante; las posiciones que consumen son contravariantes.

Por qué &mut T es invariante en T

Supón que fuera covariante. Entonces se podría pasar un &mut &'static str donde se espera un &mut &'a str:

fn overwrite<'a>(slot: &mut &'a str, value: &'a str) {
    *slot = value;
}

fn main() {
    let mut forever: &'static str = "static";
    {
        let short = String::from("short-lived");
        overwrite(&mut forever, &short); // ❌ error[E0597]: `short` no vive lo suficiente
    }
    println!("{forever}"); // leería memoria liberada
}

Con covarianza, el compilador encogería &mut &'static str a &mut &'a str, la función guardaría en forever una referencia de vida corta y la última línea sería un uso después de liberar. La invarianza obliga a que 'a sea exactamente 'static, algo que short no puede cumplir. El mensaje de error es la varianza en acción.

El mismo razonamiento explica Cell<T> y todos los demás tipos con mutabilidad interior: un &Cell<T> compartido permite escribir, así que no puede ser covariante.

Fíjate en que &'a mut T sigue siendo covariante en 'a: acortar el tiempo durante el que mantienes un préstamo exclusivo siempre es seguro.

Contravarianza

Los argumentos de función son la única fuente de contravarianza. Una función que puede tratar cualquier lifetime se puede usar donde se requiere una función que solo trata 'static:

fn print_any<'a>(s: &'a str) {
    println!("{s}");
}

fn main() {
    // Una fn(&'a str) para todo 'a se puede usar como fn(&'static str):
    let f: fn(&'static str) = print_any;
    f("hello");
}

Ir en la otra dirección —usar una función que exige una entrada 'static donde puede llegar una entrada arbitraria— sería incorrecto, y se rechaza.

La varianza de tus propios tipos

La varianza se infiere a partir de los campos. Un struct es covariante en un parámetro solo si todos los usos de ese parámetro son covariantes; un solo uso invariante hace invariante todo el struct.

use std::cell::Cell;

struct Reader<'a> { data: &'a str }            // covariante en 'a
struct Slot<'a> { data: Cell<&'a str> }        // invariante en 'a

fn shrink_reader<'short>(r: Reader<'static>) -> Reader<'short> {
    r // Correcto: la covarianza permite que Reader<'static> pase a ser Reader<'short>
}

// fn shrink_slot<'short>(s: Slot<'static>) -> Slot<'short> { s }
// ❌ no compilaría: Slot es invariante, así que los lifetimes deben coincidir exactamente.

fn main() {
    let r = shrink_reader(Reader { data: "x" });
    let s = Slot { data: Cell::new("y") };
    println!("{} {}", r.data, s.data.get());
}

Cuando un struct solo contiene punteros crudos, el compilador no tiene ningún campo del que inferir: un parámetro que no aparece en ninguna parte es un error (E0392). Indicas la relación que quieres con PhantomData:

Quieres Escribe
Covariante, es dueño de un T (afecta al drop check) PhantomData<T>
Covariante, no es dueño PhantomData<fn() -> T> o PhantomData<*const T>
Contravariante PhantomData<fn(T)>
Invariante PhantomData<fn(T) -> T> o PhantomData<*mut T>
Ligar a un lifetime, covariante PhantomData<&'a T>
Ligar a un lifetime, invariante PhantomData<&'a mut T> o PhantomData<Cell<&'a ()>>

Las formas con punteros además quitan Send y Sync; las formas con fn no. Elige teniendo en cuenta los dos efectos.

Una consecuencia real para la corrección

Si implementas una colección con *mut T, es invariante por defecto: segura, pero innecesariamente estricta, porque los usuarios no pueden pasar un MyVec<&'static str> donde se espera un MyVec<&'a str>. La biblioteca estándar usa NonNull<T>, que es covariante, más PhantomData<T> para expresar la propiedad.

El error contrario es el peligroso. Un tipo parecido a una celda que da acceso de escritura a través de &self pero que se declara covariante permite que el código seguro reproduzca el exploit de overwrite de arriba. En caso de duda, sé invariante.

Los lifetimes invariantes son también una herramienta: como un lifetime invariante no puede unificarse con ningún otro, puede servir de marca única en tiempo de compilación. El diseño de GhostCell (Yanovski et al., ICFP 2021) usa un lifetime marcado para separar el permiso de los datos, lo que da mutación compartida segura y de coste cero.

Ejercicios

  1. Para cada tipo, indica la varianza en cada parámetro y después confírmala escribiendo una función de coerción que compile o falle: struct A<'a, T>(&'a T), struct B<'a, T>(&'a mut T), struct C<T>(fn(T)), struct D<T>(fn() -> T), struct E<T>(fn(T) -> T).
  2. Explica por qué un Vec<&'static str> se puede pasar a fn f<'a>(v: Vec<&'a str>), pero un &mut Vec<&'static str> no se puede pasar a fn g<'a>(v: &mut Vec<&'a str>, s: &'a str) junto con una cadena local.
  3. Define struct MyBox<T> { ptr: *mut T }. Muestra un uso que falle por la invarianza; arréglalo con NonNull<T>.
  4. Lee el capítulo «Subtyping and Variance» del Rustonomicon y reproduce su ejemplo assign.
Respuestas del 1

A: covariante en 'a y en T. B: covariante en 'a, invariante en T. C: contravariante en T. D: covariante en T. E: invariante en T (aparece a la vez en una posición contravariante y en una covariante).

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿Qué afirmación sobre el subtipado de lifetimes es correcta?

  2. 2.¿Cuál es la varianza de &'a mut T en T?

  3. 3.¿Cuál es la varianza de fn(T) -> U?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?