Referencias mutables &mut T: modificar sin poseer

La referencia compartida solo mira. Cuando una función necesita cambiar un valor sin apropiárselo, Rust ofrece la referencia mutable &mut T: un préstamo que concede acceso de lectura y escritura al dato del dueño. Pero viene con una condición inflexible que es el corazón de toda la seguridad del lenguaje: mientras esa referencia mutable vive, es la única vía de acceso al valor. Exclusividad total, verificada en compilación.

Modificar a través de una referencia

Para mutar un valor prestado, la función pide &mut T y el llamador lo cede con &mut valor. El dato no cambia de dueño: se modifica en el sitio, y al volver de la llamada el dueño conserva el valor ya alterado.

fn agranda(s: &mut String) {
    s.push_str(" ampliado");  // muta en el sitio a través del préstamo
}

fn main() {
    let mut texto = String::from("informe");
    agranda(&mut texto);      // préstamo mutable temporal
    println!("{texto}");      // "informe ampliado": seguimos siendo dueños
}

Como con &, el operador punto autodereferencia: s.push_str(...) es azúcar de (*s).push_str(...). Cuando el dato es un valor simple, en cambio, escribes el * a mano para asignarle:

fn incrementa(r: &mut i32) {
    *r += 1;   // `*r` es el lugar; escribir ahí modifica el `i32` del dueño
}

fn main() {
    let mut n = 41;
    incrementa(&mut n);   // requiere que `n` sea `mut`
    assert_eq!(n, 42);
}

La biblioteca estándar explota esta capacidad para operaciones que en otros lenguajes exigen variables temporales. std::mem::swap intercambia dos valores a través de sendas referencias mutables, y std::mem::replace sustituye el contenido devolviéndote el anterior, todo sin mover la propiedad de ningún binding:

use std::mem;

fn main() {
    let mut a = String::from("izquierda");
    let mut b = String::from("derecha");
    mem::swap(&mut a, &mut b);          // intercambia sin clonar ni mover los bindings
    assert_eq!(a, "derecha");

    let mut activo = String::from("v1");
    let anterior = mem::replace(&mut activo, String::from("v2")); // deja "v2", devuelve "v1"
    assert_eq!(anterior, "v1");
    assert_eq!(activo, "v2");
}

El dueño debe ser mut

No puedes prestar mutablemente lo que no es mutable. Para escribir &mut x, la variable x tiene que declararse mut. Es coherente con el nivel 3: la mutabilidad es una propiedad del binding, y un préstamo mutable no puede conceder un poder que el dueño no tiene.

let inmutable = String::from("fija");
// let r = &mut inmutable;  // ERROR E0596: no puedes prestar `inmutable` como mutable

let mut variable = String::from("cambiable");
let r = &mut variable;      // OK: el dueño es `mut`
r.push('!');

Una sola mutable a la vez

Aquí está la regla que lo define todo. Mientras exista una referencia mutable a un valor, no puede existir ninguna otra referencia a ese valor —ni otra mutable, ni una compartida—. El préstamo mutable es exclusivo: es, temporalmente, el único camino hacia el dato.

let mut v = vec![1, 2, 3];
let a = &mut v;
// let b = &mut v;   // ERROR E0499: no puede haber dos `&mut` al mismo valor
a.push(4);           // mientras `a` viva, es el único acceso a `v`
println!("{v:?}");   // [1, 2, 3, 4]

El compilador reporta esto con el error E0499 (“cannot borrow v as mutable more than once at a time”) si intentas dos mutables, o E0502 si mezclas una mutable con una compartida. No es una limitación caprichosa: es la garantía que hace segura la mutación, como veremos ahora.

Por qué la exclusividad: aliasing más mutación es el desastre

Aliasing (dos referencias al mismo dato) es inofensivo mientras nadie escriba. Mutación es inofensiva mientras nadie más mire. El desastre nace de combinar ambos: mutar un dato que otro está observando. Ese es el patrón de bug que la exclusividad de &mut elimina de raíz.

let mut v = vec![1, 2, 3];
let primero = &v[0];   // préstamo compartido de un elemento
// v.push(4);          // ERROR E0502: `push` necesita `&mut`, pero `primero` sigue vivo
println!("{primero}");

Si Rust permitiera ese push, el Vec podría reasignar su buffer para crecer, dejando a primero apuntando a memoria ya liberada: una referencia colgante y un use-after-free. En C++ esto es la clásica invalidación de iteradores, un bug silencioso que corrompe memoria en ejecución. Rust lo convierte en un error de compilación: la referencia compartida primero bloquea cualquier préstamo mutable de v mientras siga viva.

flowchart TB
o[Valor declarado mut] -->|un unico prestamo| m[Referencia mutable exclusiva]
m -->|concede| w[Leer y escribir en el sitio]
o -->|mientras m viva| bloq[Ningun otro acceso al valor]

Reborrow: la mutable no es Copy

A diferencia de &T, la referencia mutable no implementa Copy —duplicar un &mut T produciría dos accesos exclusivos al mismo dato, una contradicción—. Entonces, ¿cómo pasas la misma &mut a dos funciones seguidas sin perderla? Gracias al reborrow: el compilador presta a través de la referencia en vez de moverla.

fn incrementa(r: &mut i32) { *r += 1; }

fn main() {
    let mut n = 10;
    let r = &mut n;
    incrementa(r);       // REBORROW implícito: se presta `&mut *r`, no se mueve `r`
    incrementa(r);       // `r` sigue usable porque el reborrow anterior ya terminó
    println!("{n}");     // 12
}

En cada llamada, el compilador inserta un préstamo temporal &mut *r que dura solo lo que dura la función; al volver, r recupera su exclusividad y puede represtarse. El reborrow es lo que hace ergonómicas las referencias mutables sin romper la exclusividad: nunca hay dos accesos mutables simultáneos, solo uno detrás de otro.