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:
Fes covariante siF<Sub>es un subtipo deF<Super>: la relación se mantiene.Fes contravariante siF<Super>es un subtipo deF<Sub>: la relación se invierte.Fes 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
- 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). - Explica por qué un
Vec<&'static str>se puede pasar afn f<'a>(v: Vec<&'a str>), pero un&mut Vec<&'static str>no se puede pasar afn g<'a>(v: &mut Vec<&'a str>, s: &'a str)junto con una cadena local. - Define
struct MyBox<T> { ptr: *mut T }. Muestra un uso que falle por la invarianza; arréglalo conNonNull<T>. - 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.¿Qué afirmación sobre el subtipado de lifetimes es correcta?
2.¿Cuál es la varianza de
&'a mut TenT?3.¿Cuál es la varianza de
fn(T) -> U?