FerrousPath

Nivel 2 · Practicante· Lección 3 de 8 · 30 min

Lifetimes

Cómo razona el compilador sobre cuánto tiempo siguen siendo válidas las referencias, qué significan las anotaciones y cuándo tienes que escribirlas.

Las referencias no deben sobrevivir a su referente

Toda referencia tiene un lifetime (tiempo de vida): la región del código en la que es válida. El trabajo del borrow checker es garantizar que ninguna referencia se usa después de que haya desaparecido el valor al que apunta.

fn main() {
    let r;
    {
        let x = 5;
        r = &x; // ❌ error[E0597]: `x` no vive lo suficiente
    }           // x se libera aquí…
    println!("{r}"); // …pero r se usa aquí
}

La mayor parte del tiempo los lifetimes se infieren y nunca los escribes. Las anotaciones se vuelven necesarias cuando el compilador no puede saber cómo se relacionan las referencias de una firma.

Por qué existen las anotaciones

fn longest(a: &str, b: &str) -> &str { // ❌ error[E0106]: falta un especificador de lifetime
    if a.len() >= b.len() { a } else { b }
}

fn main() {
    println!("{}", longest("ab", "abc"));
}

La referencia devuelta toma prestado de a o de b, pero ¿de cuál? El compilador comprueba cada función de forma aislada, usando solo las firmas de las funciones a las que llama. Necesita que la firma diga durante cuánto tiempo es válido el resultado:

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

fn main() {
    let first = String::from("a long string");
    let result;
    {
        let second = String::from("short");
        result = longest(&first, &second).to_string(); // copia mientras las dos están vivas
    }
    println!("{result}");
}

Lee <'a> así: «existe alguna región 'a durante la cual las dos entradas son válidas, y la salida también es válida durante esa región». En cada llamada el compilador elige 'a como el solapamiento de los lifetimes de los dos argumentos. La anotación no hace que nada viva más tiempo: es un contrato que quien llama debe poder cumplir.

Si el resultado solo puede venir de uno de los argumentos, dilo, y quienes llamen tendrán más libertad:

fn first_word<'a>(text: &'a str, _separator: &str) -> &'a str {
    text.split_whitespace().next().unwrap_or("")
}

fn main() {
    let text = String::from("hello world");
    let word;
    {
        let sep = String::from(" ");
        word = first_word(&text, &sep);
    } // sep ya no existe, y no pasa nada: el resultado no toma prestado de él
    println!("{word}");
}

Elisión de lifetimes

Has escrito muchas funciones que devuelven referencias sin anotaciones. Tres reglas las completan:

  1. Cada lifetime de entrada omitido se convierte en un parámetro propio.
  2. Si hay exactamente un lifetime de entrada, se asigna a todas las salidas.
  3. Si una de las entradas es &self o &mut self, su lifetime se asigna a todas las salidas.

Si después de aplicar estas reglas las salidas siguen sin determinarse, tienes que anotar. Las reglas son comodidades puramente sintácticas: nunca miran el cuerpo de la función.

Structs que guardan referencias

Un struct que almacena una referencia necesita un parámetro de lifetime: el struct no puede sobrevivir a aquello que toma prestado.

#[derive(Debug)]
struct Excerpt<'a> {
    text: &'a str,
}

impl<'a> Excerpt<'a> {
    fn first_sentence(source: &'a str) -> Self {
        Excerpt { text: source.split('.').next().unwrap_or(source) }
    }

    // Regla de elisión 3: el resultado toma prestado de self.
    fn words(&self) -> usize {
        self.text.split_whitespace().count()
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago…");
    let e = Excerpt::first_sentence(&novel);
    println!("{e:?} has {} words", e.words());
}

Así funcionan los analizadores sin copia (zero-copy): la estructura analizada está llena de slices que apuntan al búfer de entrada, y el compilador garantiza que el búfer los sobrevive.

Consejo de diseño. Si las anotaciones de lifetime se extienden por tu programa y te lo ponen difícil, pregúntate si el struct debería ser dueño de sus datos (String en lugar de &str). Tomar prestado dentro de structs es una optimización; ser dueño es lo predeterminado.

'static

'static es el lifetime de todo el programa. Los literales de cadena son &'static str porque viven en el binario.

Como restricción, T: 'static significa algo más sutil: T no contiene datos prestados que puedan caducar. Los tipos con dueño, como String y Vec<u8>, la cumplen. La verás en std::thread::spawn, que exige que su clausura sea 'static porque el hilo nuevo puede sobrevivir al marco de pila de quien lo lanza.

Cuando un mensaje de error sugiere añadir 'static, rara vez es la solución correcta. Normalmente significa que intentas mantener un préstamo más tiempo del que vive su dueño, y que deberías ser dueño de los datos.

Los lifetimes son regiones, no ámbitos

El borrow checker razona sobre el grafo de flujo de control, un sistema llamado lifetimes no léxicos (NLL, non-lexical lifetimes). Un préstamo dura desde su creación hasta su último uso a lo largo de cada camino.

fn main() {
    let mut scores = vec![1, 2, 3];
    let first = &scores[0];
    println!("{first}");  // último uso de `first`
    scores.push(4);       // correcto: el préstamo compartido ya terminó
    println!("{scores:?}");
}

El nivel 5 examina en detalle NLL y su sucesor, Polonius.

Ejercicios

  1. Escribe fn longest_word<'a>(text: &'a str) -> &'a str. Después borra las anotaciones y explica por qué sigue compilando.
  2. Escribe un struct Splitter<'a> { rest: &'a str, sep: char } con un método next_piece(&mut self) -> Option<&'a str> que devuelva los trozos sucesivos.
  3. ¿Por qué se rechaza esto, y cuáles son dos formas de arreglarlo? fn make() -> &str { let s = String::from("x"); &s }
Solución del 2
struct Splitter<'a> { rest: &'a str, sep: char }

impl<'a> Splitter<'a> {
    fn next_piece(&mut self) -> Option<&'a str> {
        if self.rest.is_empty() {
            return None;
        }
        match self.rest.split_once(self.sep) {
            Some((head, tail)) => { self.rest = tail; Some(head) }
            None => { let last = self.rest; self.rest = ""; Some(last) }
        }
    }
}

fn main() {
    let mut s = Splitter { rest: "a,b,c", sep: ',' };
    while let Some(p) = s.next_piece() {
        println!("{p}");
    }
}

Fíjate en que el tipo de retorno es Option<&'a str>, no ligado a &mut self. Los trozos toman prestado del texto original, así que siguen siendo válidos después de modificar o liberar el splitter.

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿Qué hace una anotación de lifetime como 'a?

  2. 2.Según las reglas de elisión, ¿cuál es el lifetime del valor de retorno de fn get(&self, key: &str) -> &str?

  3. 3.¿Qué significa la restricción T: 'static?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?