`Cell<T>`: mutar moviendo valores, sin prestar referencias

Si el problema era mutar tras un & compartido, Cell<T> lo resuelve por la vía más radical imaginable: no prestando nunca una referencia al interior. No puedes obtener un &mut al valor guardado, ni siquiera un &; solo puedes sacar una copia con get o meter un valor nuevo con set. Y como no hay ninguna referencia apuntando dentro de la Cell, no existe aliasing que pueda entrar en conflicto con la escritura: mutar es trivialmente seguro porque no hay nadie a quien sorprender. Ese es el trato de Cell: renuncias a las referencias y a cambio obtienes mutación libre, sin comprobación alguna, a coste cero.

La interfaz que nunca presta

Cell<T> es una caja con una regla de oro: el contenido entra y sale por valor, jamás por referencia. Su API refleja esa disciplina.

use std::cell::Cell;

let c = Cell::new(5);

c.set(10);                       // sobrescribe: mete un valor nuevo
let x = c.get();                 // saca una COPIA del valor actual -> 10
let viejo = c.replace(20);       // devuelve el anterior (10) y guarda 20
let n = c.take();                // deja Default::default() y devuelve lo que habia (20)
assert_eq!((x, viejo, n), (10, 10, 20));
assert_eq!(c.get(), 0);          // take dejo el 0 por defecto

Cuatro operaciones y ni una entrega un & al interior. get exige T: Copy porque saca el valor duplicándolo: si no fuera copiable, tendría que moverlo fuera —dejando la celda vacía— o prestarlo —lo que rompería la regla—. Para tipos que no son Copy, usas replace (das uno a cambio), take (dejas el Default) o set (descartas el previo), pero nunca get.

Mutar a través de &self

Aquí Cell cumple su promesa: convierte un método &self en un método que puede mutar. Retomemos el contador del nivel anterior, ahora funcional:

use std::cell::Cell;

struct Pagina {
    visitas: Cell<u32>,
}

impl Pagina {
    fn ver(&self) {                          // &self, no &mut self
        let previas = self.visitas.get();
        self.visitas.set(previas + 1);       // muta tras una referencia compartida
    }
}

fn main() {
    let p = Pagina { visitas: Cell::new(0) };
    p.ver();
    p.ver();
    p.ver();
    assert_eq!(p.visitas.get(), 3);
}

ver toma &self y aun así incrementa el contador. Nada en el tipo de p delata que hay mutación; la firma sigue prometiendo “no te muevo el objeto”, y es cierta: lo que cambia es un dato interior cuya seguridad garantiza Cell, no el borrow checker. Para el llamador, p sigue siendo compartible con toda tranquilidad.

flowchart LR
fuera[Valor fuera] -->|set mete una copia| dentro[Valor dentro de la Cell]
dentro -->|get saca una copia| copia[Copia independiente fuera]
dentro -->|replace guarda el nuevo y devuelve el viejo| copia
style dentro fill:#89b4fa,color:#11111b
style copia fill:#a6e3a1,color:#11111b

Coste cero: qué paga y qué no

La consecuencia más notable de no prestar referencias es que Cell no necesita llevar ninguna contabilidad. RefCell, que sí presta, tiene que guardar un contador de préstamos; Cell no guarda nada extra. Es repr(transparent) sobre su primitiva interna, de modo que su tamaño y su alineación son idénticos a los de T:

use std::cell::Cell;
use std::mem::size_of;

assert_eq!(size_of::<Cell<u32>>(), size_of::<u32>());   // sin bytes de mas
assert_eq!(size_of::<Cell<[u8; 16]>>(), 16);            // exactamente el contenido

En el binario, get y set compilan a una lectura y una escritura de memoria corrientes: no hay ramas, ni bloqueos, ni banderas que consultar. Cell es, literalmente, mutación sin fricción. Cuando &mut self te viene grande solo porque necesitas tocar un u32 o un bool, Cell es la herramienta exacta.

Más allá del contador

Cell no se limita a enteros sueltos. Cualquier tipo Copy cabe dentro, y eso incluye un Option<T> copiable, con el que se arma una memoización sencilla: calcular una vez, guardar, devolver la copia después.

use std::cell::Cell;

struct Circulo {
    radio: f64,
    area_cache: Cell<Option<f64>>,
}

impl Circulo {
    fn area(&self) -> f64 {                       // &self, y aun asi cachea
        if let Some(a) = self.area_cache.get() {
            return a;                             // ya calculada antes
        }
        let a = std::f64::consts::PI * self.radio * self.radio;
        self.area_cache.set(Some(a));            // memoiza tras un &
        a
    }
}

Como Option<f64> es Copy, get y set bastan y el patrón conserva su coste mínimo. El límite reaparece en cuanto el resultado a cachear no sea Copy —un String, un Vec—: entonces get deja de servir, porque tendría que mover o prestar, y el trabajo pasa a RefCell, la siguiente puerta.