Guía completa de ownership, borrowing y lifetimes en Rust

Si programas en Rust a medio nivel, las reglas de ownership, borrowing y lifetimes se vuelven críticas. Aquí tienes una guía práctica y clara: conceptos, ejemplos reales, errores comunes y patrones para evitar problemas en código concurrente y asíncrono.

1. Conceptos esenciales (rápido)

• Ownership: cada valor tiene un único owner. Mover consume el owner.
• Borrowing: referenciar un valor con &T (inmutable) o &mut T (mutable). Regla: muchas referencias inmutables o una mutable, no ambas.
• Lifetimes: anotaciones que describen cuánto tiempo viven las referencias; evitan referencias colgantes.

2. Ejemplos básicos

Movimiento y copia

fn move_example() {
    let s1 = String::from("hola");
    let s2 = s1; // s1 fue movido a s2
    // println!("{}", s1); // error: use of moved value
}

fn copy_example() {
    let x = 5;
    let y = x; // i32 es Copy, x sigue usable
    println!("{} {}", x, y);
}

Borrowing inmutable vs mutable

fn borrow_example() {
    let mut s = String::from("hola");
    let r1 = &s; // OK, inmutable
    let r2 = &s; // OK, múltiples inmutables
    // let r3 = &mut s; // error: cannot borrow `s` as mutable because it's also borrowed as immutable
    println!("{} {}", r1, r2);

    let r4 = &mut s; // OK, si no hay otras referencias activas
    r4.push_str(" mundo");
    println!("{}", r4);
}

3. Lifetime elision y anotaciones

Reglas de elisión hacen que muchas funciones no necesiten explícitamente anotaciones. Pero cuando devuelves una referencia tomada de parámetros, debes especificar lifetimes.

// El siguiente ejemplo requiere una anotación de lifetime
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn use_longest() {
    let s1 = String::from("abcd");
    let s2 = "xyz";
    let res = longest(s1.as_str(), s2);
    println!("La más larga: {}", res);
}

Si intentas devolver una referencia a una variable local, el compilador lo rechazará (evita dangling references):

fn invalid() -> &String {
    let s = String::from("hola");
    &s // error: `s` no vive lo suficiente
}

4. Lifetimes en structs

Cuando un struct contiene referencias, necesita una anotación de lifetime.

struct RefHolder<'a> {
    part: &'a str,
}

impl<'a> RefHolder<'a> {
    fn new(p: &'a str) -> Self { RefHolder { part: p } }
    fn part(&self) -> &str { self.part }
}

fn use_holder() {
    let s = String::from("hello world");
    let h = RefHolder::new(&s);
    println!("{}", h.part());
}

Patrón práctico: si tu tipo necesita vivir más que el owner externo, cambia a tipos propietarios (String, Vec) o smart pointers (Box, Rc, Arc).

5. Subtipado de lifetimes y scopes

Las referencias con un lifetime más corto no pueden asignarse a referencias con un lifetime más largo. Ejemplo clásico:

fn scope_error() {
    let r: &i32;
    {
        let x = 5;
        r = &x; // `x` no vive lo suficiente
    }
    // r apunta a memoria liberada: error
}

6. 'static y literales

Las cadenas literales tienen lifetime 'static:

let s: &'static str = "cadena literal";

Ten cuidado: 'static no significa necesariamente "estático en tiempo de compilación" en todos los contextos; significa que la referencia puede vivir todo el programa. Evita usar 'static como parches para ocultar problemas de diseño.

7. Evitar problemas con smart pointers

Muchos problemas de borrowing se resuelven usando tipos propietarios o smart pointers:

• String/Vec: evita referencias en structs cuando no son necesarias.
• Box: para enrutar ownership sin copiar grandes estructuras.
• Rc/Arc: contadores de referencias para compartir ownership; Arc para concurrencia.
• Cow<'a, T>: útil para APIs que aceptan referencia u ownership y quieren evitar clones innecesarios.

use std::sync::Arc;

fn arc_example() {
    let data = Arc::new(String::from("shared"));
    let t = std::thread::spawn({
        let d = Arc::clone(&data);
        move || println!("from thread: {}", d)
    });
    println!("from main: {}", data);
    t.join().unwrap();
}

8. Errores comunes y cómo arreglarlos

1. Missing lifetime specifier: al declarar struct con referencias. Solución: añadir 'a en struct e impl.
2. Retornar referencia a variable local: mueve a propietario o cambie la API para devolver un String/Vec.
3. Conflicto mutable/inmutable: revisa scopes: borrows inmutables vencen cuando ya no se usan; reestructura para que la mutable ocurra en otro bloque.
4. async + lifetimes: los futuros suelen requerir 'static para ser enviados a hilos; usa move + Arc/clone o devuelve tipos propietarios.

// Ejemplo típico: futuro que captura variable no-'static
async fn do_work(s: &String) { println!("{}", s); }

// Para spawn en tokio::spawn necesitas que el futuro sea 'static:
// tokio::spawn(do_work(&s)); // error si s no es 'static
// Solución: clonar/Arc o hacer la función tomar ownership

9. HRTB (Higher-Ranked Trait Bounds) y lifetimes genéricos

Útil cuando quieres aceptar closures que funcionen para cualquier lifetime:

fn apply_to_str(f: F)
where
    F: for<'a> Fn(&'a str) -> &'a str,
{
    let s = String::from("hola");
    let r = f(&s);
    println!("{}", r);
}

// `for<'a>` significa: f debe funcionar para cualquier lifetime `'a`.

10. Patrones recomendados

• Preferir devolver tipos propietarios (String, Vec) desde APIs públicas para simplificar lifetimes.
• Usar referencias en structs sólo si tienes control explícito sobre el owner y su scope.
• Prefiere Arc/Rc para compartir datos que deban vivir más allá de un scope único.
• En async, evita capturar referencias no-'static en tareas que se envían entre threads; usa move + Arc o borra propiedad.
• Usa Cow cuando quieras API flexible sin clones innecesarios.

11. Diagnóstico con el compilador

Los mensajes del compilador son explícitos respecto a lifetimes: lee la sugerencia, revisa el scope de las variables implicadas, y prueba reestructurar bloques en lugar de añadir 'static arbitrario. Herramientas útiles: rustc -Z borrowck=mir (para debugging avanzado), clippy para sugerencias idiomáticas.

12. Ejemplo práctico: API simple segura

Supongamos que quieres una API que extraiga una palabra de un texto y la devuelva sin obligar al caller a clonar:

fn first_word(s: &str) -> &str {
    for (i, &b) in s.as_bytes().iter().enumerate() {
        if b == b' ' { return &s[0..i]; }
    }
    &s[..]
}

fn example() {
    let s = String::from("hello world");
    let w = first_word(&s);
    println!("primera palabra: {}", w);
}

Este patrón funciona porque la referencia devuelta está ligada al lifetime del parámetro &str, claro y seguro.

14. Recursos y siguientes pasos

• Leer el capítulo de ownership/borrowing del libro oficial de Rust.
• Rustonomicon para casos avanzados y UB.
• Practicar reescribiendo librerías pequeñas que usen structs con referencias vs tipos propietarios y comparar diseño y ergonomía.

Consejo avanzado: cuando el compilador no acepta una referencia que sabes que es segura, intenta reformular el ownership (propiedad explícita o smart pointers) en vez de forzar lifetimes; esto mejora la mantenibilidad. Advertencia: usar 'static o lifetimes excesivamente amplios puede ocultar problemas de diseño y provocar leaks lógicos o sincronización incorrecta en concurrencia. Siguiente paso: implementa una pequeña API que use Cow, Arc y lifetimes explícitos para comparar rendimiento y ergonomía en tu caso real.