Lifetimes en trait objects: `dyn Trait + 'a` y el `'static` implicito

Cuando borras un tipo detras de dyn Trait, el compilador pierde de vista su forma concreta —y con ella, cuanto viven las referencias que ese tipo pudiera guardar dentro—. Para no perder la seguridad, cada objeto de trait carga un lifetime implicito que acota exactamente eso: dyn Trait + 'a promete que el tipo borrado no contiene ninguna referencia mas corta que ’a. Lo desconcertante es que ese lifetime casi nunca se escribe, y sus defectos cambian segun el contenedor: Box<dyn Trait> asume 'static, pero &'a dyn Trait asume 'a. Esta leccion descifra esos defectos, explica por que existen, y te ensena a relajarlos para almacenar objetos que toman prestado de su entorno.

Por que un objeto de trait necesita un lifetime

Un Box<dyn Dibuja> puede esconder cualquier tipo que implemente Dibuja: uno que posea todos sus datos, o uno que guarde una referencia prestada. El compilador, tras el borrado, no distingue cual es —esa es toda la gracia del despacho dinamico—. Pero entonces surge un peligro: si el tipo oculto guardaba un &'corto str, el objeto no puede sobrevivir a esa region, o accederiamos a memoria muerta a traves de la vtable. La cota + 'a es la promesa que cierra ese agujero: el tipo borrado sobrevive al menos a ’a, formalmente ConcretoBorrado: 'a.

trait Dibuja { fn render(&self) -> String; }

// Estas dos anotaciones dicen cosas distintas sobre el tipo escondido:
fn _a(_x: Box<dyn Dibuja + 'static>) {}   // el tipo borrado no guarda prestamos efimeros
fn _b<'a>(_x: Box<dyn Dibuja + 'a>) {}     // el tipo borrado puede prestar, pero sobrevive a 'a

Que ese + 'a sea parte del tipo del objeto, y no un detalle interno, es lo que permite al borrow checker seguir razonando sobre vidas incluso despues de haber perdido el tipo concreto. El borrado esconde la forma, pero nunca la region.

Los defectos: por que Box<dyn Trait> es 'static

Casi nunca escribes ese + 'a, y sin embargo esta siempre. La razon es un conjunto de reglas de lifetime por defecto para objetos de trait, distintas de la elision de funciones. Se aplican en este orden:

El caso que mas sorprende es el primero. Box<dyn Trait> no es “un objeto de vida cualquiera”: es Box<dyn Trait + 'static>, la restriccion mas fuerte posible. La logica del defecto es la prudencia: un Box puede moverse a cualquier parte, devolverse de una funcion, guardarse en una estructura de larga vida; sin ninguna region del contexto que lo limite, el compilador asume lo unico universalmente seguro —que el tipo borrado no depende de ningun prestamo efimero—. Por eso un Box<dyn Trait> que intente contener una referencia local falla, y el mensaje habla de 'static aunque tu no lo escribieras.

Ver los tres defectos escritos como los desazucara el compilador disuelve casi toda la confusion:

// Lo que escribes    ->    lo que el compilador entiende
//  Box<dyn Dibuja>         Box<dyn Dibuja + 'static>       (contenedor sin region: static)
//  &'a dyn Dibuja          &'a (dyn Dibuja + 'a)           (hereda la region del prestamo)
//  &dyn Dibuja             &'a (dyn Dibuja + 'a)           (misma regla con 'a elidido)
//  Rc<dyn Dibuja>          Rc<dyn Dibuja + 'static>        (igual que Box)

trait Dibuja { fn render(&self) -> String; }
struct Etiqueta<'a> { texto: &'a str }
impl<'a> Dibuja for Etiqueta<'a> {
    fn render(&self) -> String { self.texto.to_string() }
}

fn en_caja_mal(s: &str) -> Box<dyn Dibuja> {   // = Box<dyn Dibuja + 'static>: ERROR
    Box::new(Etiqueta { texto: s })            // Etiqueta<'_> presta de s, no es 'static
}

Relajar el defecto: + 'a para objetos que prestan

La cura no es forzar 'static sobre los datos ni clonar a lo bruto: es relajar el defecto declarando la region real del objeto. Anadiendo + 'a al tipo del objeto le dices al compilador “este objeto puede prestar, pero yo garantizo que vive dentro de ’a”.

// Relajado: el objeto puede contener referencias, atadas a la region 'a de la entrada.
fn en_caja_bien<'a>(s: &'a str) -> Box<dyn Dibuja + 'a> {
    Box::new(Etiqueta { texto: s })   // ahora el + 'a admite el prestamo de s
}

El caso practico por excelencia son los closures que capturan por referencia. Un Box<dyn Fn()> es Box<dyn Fn() + 'static> y rechaza capturar prestamos locales; para almacenar una devolucion de llamada que toma prestado de su entorno, anotas + 'a (o + '_, dejando que la region se infiera del contexto).

fn hacer_callback<'a>(datos: &'a [i32]) -> Box<dyn Fn() -> usize + 'a> {
    Box::new(move || datos.len())   // captura &'a [i32]; el + 'a lo autoriza
}

flowchart TB
o[dyn Trait sin lifetime escrito] --> c[En que contenedor esta?]
c -->|Box, Arc, Rc| s[Defecto static: no puede prestar]
c -->|ref con vida a| r[Defecto a: hereda la region del prestamo]
c -->|tipo con un solo lifetime| t[Defecto: ese lifetime]
s --> need[El objeto necesita prestar?]
need -->|si| relax[Relaja escribiendo mas a en el tipo del objeto]
need -->|no| ok[static esta bien]