Conversiones y NonNull: referencias, punteros y direcciones

Referencia, puntero crudo y dirección numérica son tres formas de decir “dónde está esto”, y buena parte de la programación de bajo nivel consiste en moverse entre ellas con precisión. El triángulo tiene una geometría clara: bajar de referencia a puntero es seguro porque tiras garantías; subir de puntero a referencia es unsafe porque las reafirmas; y convertir a usize y de vuelta cruza además la frontera de la procedencia. Pero hay un cuarto vértice que las estructuras de datos serias no pueden ignorar: NonNull<T>, un puntero crudo con una única promesa cosida al tipo —que nunca es nulo—. Esa promesa, aparentemente modesta, desbloquea el nicho que hace que Option<NonNull<T>> no ocupe ni un byte de más, la covarianza que las referencias tienen y los punteros crudos no, y por eso es el ladrillo con el que Box, Rc, Arc y Vec están construidos por dentro.

El triángulo: referencia, puntero, dirección

Bajar de referencia a puntero es una coerción segura: descartas promesas, no las inventas. Subir de puntero a referencia con &*p o &mut *p es unsafe, porque ahí sí reafirmas las cuatro invariantes —y una quinta traicionera, el lifetime—. Cruzar a usize con as o addr extrae la dirección; volver desde un entero fabrica un puntero cuya procedencia has de justificar.

let mut n = 5_i32;
let p: *mut i32 = &raw mut n;

let dir: usize = p.addr();              // procedencia estricta: solo la direccion
let pc: *const i32 = p.cast_const();    // mut a const
let otro: *const u8 = p.cast();         // reinterpreta el tipo apuntado

let r: &mut i32 = unsafe { &mut *p };   // puntero a referencia: unsafe
*r += 1;
assert_eq!(n, 6);

La trampa más silenciosa vive en &*p. Al reconstruir una referencia, tú eliges su lifetime, y si no lo acotas el compilador le concede uno tan largo como haga falta —un lifetime sin límite— que puede sobrevivir a la memoria apuntada y abrir un use-after-free que el borrow checker no verá venir. La disciplina es atar siempre la referencia reconstruida a un lifetime real, típicamente el de la estructura que posee la memoria.

NonNull: el puntero que promete no ser nulo

NonNull<T> es un *mut T con una invariante grabada en el tipo: jamás es nulo. Esa promesa cambia tres cosas. Primero, habilita el nicho: como el patrón de bits “todo ceros” es imposible, el compilador lo reutiliza para representar None, y Option<NonNull<T>> ocupa exactamente lo mismo que un puntero. Segundo, NonNull<T> es covariante en T, como las referencias, mientras que *mut T es invariante: eso lo hace apto para estructuras genéricas donde la varianza importa. Tercero, documenta la invariante para quien lea el tipo.

use std::ptr::NonNull;
use std::mem::size_of;

let mut n = 42_i32;
let nn: NonNull<i32> = NonNull::new(&raw mut n).unwrap();  // new devuelve Option
unsafe {
    assert_eq!(*nn.as_ref(), 42);   // as_ref da una &T (cuidado con el lifetime)
    *nn.as_ptr() = 43;               // as_ptr recupera el *mut T
}
assert_eq!(n, 43);

// el nicho: Option sale gratis
assert_eq!(size_of::<Option<NonNull<i32>>>(), size_of::<*mut i32>());

La API es deliberadamente afilada: NonNull::new(p) devuelve Option<NonNull<T>> comprobando la nulidad; new_unchecked la omite bajo tu responsabilidad; as_ptr recupera el *mut T; as_ref y as_mut reconstruyen referencias (con el mismo cuidado de lifetime de antes); cast reinterpreta el tipo; y NonNull::dangling() fabrica un puntero no-nulo, bien alineado pero colgante, el valor idóneo para representar una colección vacía o un tipo de tamaño cero sin reservar memoria. Como los punteros crudos, NonNull no es Send ni Sync, así que los contenedores que lo envuelven declaran esas capacidades a mano cuando su invariante lo justifica.

Por qué las estructuras de datos eligen NonNull

Abre el código de Box, Rc, Arc o Vec y encontrarás NonNull (a menudo tras el envoltorio Unique) en el corazón de todas. La elección no es casual: reúne cuatro ventajas que ningún otro tipo ofrece a la vez.

use std::ptr::NonNull;

// El esqueleto de una lista: el enlace es Option<NonNull<Nodo>>, nicho incluido.
struct Nodo<T> {
    valor: T,
    siguiente: Option<NonNull<Nodo<T>>>,   // None reutiliza el patron cero
}

struct Lista<T> {
    cabeza: Option<NonNull<Nodo<T>>>,
}

En la biblioteca estándar, NonNull suele viajar envuelto en el tipo interno Unique<T>, que añade una promesa más —la propiedad exclusiva de lo apuntado— y comunica al compilador que ese puntero no aliasea, habilitando optimizaciones análogas a las de una &mut. Box y Vec lo usan por dentro; tú, desde un crate de usuario, trabajarás con NonNull directamente y reafirmarás a mano, con tus invariantes, lo que Unique afirma de fábrica.

flowchart LR
R[Referencia ref T] -->|coercion segura| P[Puntero crudo]
P -->|deref unsafe con lifetime| R
P -->|addr o as usize| D[Direccion usize]
D -->|with addr o as ptr| P
P -->|NonNull new| NN[NonNull T no nulo]
NN -->|nicho y covarianza| E[Base de Box Rc Arc Vec]
style R fill:#a6e3a1,color:#11111b
style P fill:#89b4fa,color:#11111b
style D fill:#f9e2af,color:#11111b
style NN fill:#cba6f7,color:#11111b
style E fill:#f38ba8,color:#11111b