Rust 1.100: el tipo never y una década de trabajo
Rust 1.100 estabiliza por fin el tipo never, los allocators personalizados y los cooldowns de dependencias en Cargo. Lo que enseñan 100 releases sobre diseño de lenguajes.

Este escenario debería ser memorable, pero no lo es: ejecutas rustup update stable un jueves por la mañana, reconstruyes un workspace con unos cientos de crates y medio millón de líneas de código, y todo compila. Sin warnings de deprecación que no te hayas ganado, sin roturas sorpresa en una dependencia transitiva, sin el frenético pinning de versiones. Con Rust 1.100 —una versión realmente enorme que estabiliza el tipo never después de diez años de intentos— lo más interesante es lo poco dramática que será la actualización para casi todo el mundo. Eso no es casualidad. Es el producto de cien releases de disciplina institucional, y vale la pena leer esta versión como si fuera un documento de diseño.
El tipo Never, una década en construcción
La característica estrella de la 1.100 es un tipo que, por definición, no tiene valores. El tipo never, escrito !, es el tipo deshabitado por excelencia: describe cálculos que nunca llegan a producir un valor —un bucle infinito, un return, un panic!(), una llamada a std::process::exit. Los teóricos de tipos conocen esta criatura desde hace mucho; es el tipo inferior, el ⊥ del cálculo lambda, el conjunto vacío que espera en la esquina de tu retículo de tipos. Los usuarios de Haskell la conocen como Void. Rust llevaba rondándola desde antes de la 1.0, y le costó diez años y cinco intentos fallidos de estabilización aterrizar.
¿Por qué tanta dificultad? Porque ! puede convertirse en cualquier otro tipo —que es precisamente su poder— y cada punto de coerción es un lugar donde la inferencia de tipos, la resolución de traits y la comprobación de exhaustividad tienen que ponerse de acuerdo. Como un brazo de match que diverge tiene tipo !, este código compila:
fn infallible_unwrap<T>(res: Result<T, !>) -> T {
// ^^ naming `!` in a type position like this
// was not allowed on stable before 1.100
let Ok(v) = res;
v
}
La línea let Ok(v) = res; es la recompensa: como Err(!) nunca puede existir, el compilador acepta el patrón irrefutable, y toda una categoría de llamadas defensivas a unreachable!() desaparece. Junto a esto, el antiguo enum std::convert::Infallible pasa a ser un alias de tipo para !, de modo que toda API escrita contra Infallible en los últimos años es automáticamente compatible con el tipo never real. Esa unificación era el plan desde el principio, y también fue la razón por la que la estabilización no paraba de retrasarse: cambiar el alias exigía cambiar el fallback del tipo never en las ediciones anteriores a 2024, un cambio técnicamente incompatible.
Fíjate en cómo el equipo gestionó esa ruptura, porque resume toda la filosofía en miniatura. Publicaron warnings de compatibilidad futura con mucha antelación, probaron el ecosistema con crater y enviaron proactivamente parches a los crates públicos que se verían afectados. Un cambio incompatible, ejecutado a lo largo de varios ciclos de release, con el radio de impacto medido y parcheado antes de que la mayoría de usuarios notara algo. Compáralo con la jugada habitual de la industria: subir la versión mayor y encogerse de hombros. Ya escribí sobre a qué se compromete Rust exactamente con la soundness; la historia del tipo never es la versión a nivel de proceso del mismo compromiso. Cuando tu garantía es «el código seguro no puede tener comportamiento indefinido», hasta un tipo sin ningún habitante tiene que ganarse su entrada.
Los allocators personalizados por fin tienen una base estable
Casi igual de esperado: el núcleo del trabajo de allocator_api ya es estable. El trait Allocator, Global, System y los constructores *_in —Vec::new_in, Vec::with_capacity_in, Box::new_in, Box::from_raw_in— ya se pueden usar en Rust estable. Los autores de librerías pueden definir un allocator y pasárselo a las colecciones estándar:
use std::alloc::{Allocator, Global};
// A Vec that allocates from your arena/pool/slab instead of the heap
let mut v: Vec<u64, _> = Vec::new_in(MyArena::new());
v.push(42);
Si solo has escrito código de aplicación, esto puede parecerte fontanería. Y lo es, pero la fontanería es donde viven o mueren los lenguajes de sistemas. Hasta ahora, cambiar de allocator significaba el instrumento contundente de #[global_allocator]: uno solo para todo el proceso. Eso está bien si quieres jemalloc o mimalloc en todas partes (y hay rendimiento real en juego; jemalloc se ganó su reputación a escala), pero no sirve si quieres que un solo Vec use una arena que se libera de golpe al final de una petición, mientras todo lo demás usa el heap por defecto. Motores de juego, bases de datos, targets embebidos con varias regiones de RAM, código cercano al kernel: todos quieren control por colección, y lo llevan queriendo años.
Fíjate en el encuadre de la propia release: esto es explícitamente la base del objetivo de proyecto «Allocators 1.0», con más colecciones y tipos de punteros por llegar. El proyecto Rust ya se siente cómodo diciendo «aquí está el núcleo estable; lo demás sigue deliberadamente en nightly». Esa secuenciación —estabilizar el trait y el diseño, dejar que el ecosistema construya sobre ellos y ampliar la superficie después— es exactamente cómo evitas meterte en un callejón con una API que hay que mantener para siempre. C++ siguió el camino contrario con std::allocator en los noventa: la lanzó a medio hacer y pasó décadas esquivando los destrozos. La paciencia sale más barata.
DropGuard: el defer de Go, a la manera Rust
La sorpresa de la release es std::mem::DropGuard. El trait Drop de Rust ya garantiza que el código de limpieza se ejecuta cuando un valor sale de su ámbito: return, ?, panic, da igual. Pero escribir un tipo nuevo solo para ejecutar un closure al salir es un boilerplate con el que la mayoría hemos refunfuñado. DropGuard envuelve un valor y un closure, hace deref al valor para que lo uses con normalidad y ejecuta el closure cuando el guard muere. Un método dismiss() lo desactiva. El uso canónico es el rollback transaccional:
use std::mem::DropGuard;
use std::num::ParseIntError;
/// Push every parsed string into `nums`, or leave `nums` untouched.
fn parse_all(nums: &mut Vec<u32>, strings: &[&str]) -> Result<(), ParseIntError> {
let len = nums.len();
let mut nums = DropGuard::new(nums, move |nums| {
nums.truncate(len); // rollback on failure
});
for s in strings {
nums.push(s.parse()?); // `?` exits early; the guard truncates
}
DropGuard::dismiss(nums); // success: keep the values
Ok(())
}
Si esto huele a defer de Go, es que lo es, pero con una diferencia crucial en dónde vive la garantía. El defer de Go es una sentencia con ámbito de función: se ejecuta al retornar la función y es invisible para el sistema de tipos. DropGuard es un valor. Puedes moverlo, guardarlo, pasárselo a otro ámbito o desactivarlo condicionalmente. La genealogía pasa por el RAII de C++ y por el viejo truco de ScopeGuard de Alexandrescu, de los primeros tiempos del C++ moderno, que hacía lo mismo con destructores y una llamada a Dismiss(). Rust no inventó la idea; absorbió un modismo de C++ de veinte años, le dio semántica de ownership y lo metió en core. Así es como funciona de verdad la buena evolución de un lenguaje: no novedad, sino adopción de patrones probados en el vocabulario estándar.

Invocar la nada: tipos de tamaño cero bien hechos
Más abajo en las notas hay una función cuyo nombre me encanta: std::mem::conjure_zst. Los tipos de tamaño cero —structs unitarios, tokens de marcado como el Python<'py de PyO3— están por todas partes en la programación a nivel de tipos de Rust. Si un tipo habitado no ocupa tamaño, solo puede contener un valor, así que crearlo es, en cierto sentido, siempre «seguro». Pero las APIs dependen con frecuencia de que esos tokens sean imposibles de falsificar: invocar un Python<'py de la nada permitiría que código seguro fingiera tener el GIL. Antes, la gente invocaba los ZST con transmutes de () o conjuros con MaybeUninit, cada uno con implicaciones sutilmente distintas para las guías de código unsafe, todavía sin decidir. Ahora hay una única forma bendecida y ruidosamente unsafe de hacerlo. Es una función diminuta que existe para que una gran pregunta de especificación tenga una respuesta única y auditable. Aburrida, cuidadosa, correcta: toda la release en una API.
Los cooldowns de dependencias en Cargo: defensa de la cadena de suministro con temporizador
El cambio con más consecuencias de la 1.100 quizá ni siquiera esté en el lenguaje. Cargo ahora soporta resolución de dependencias consciente de min-publish-age: los cooldowns de dependencias. La idea de fondo es empírica: las versiones maliciosas de paquetes suelen detectarse en horas o días desde su publicación, ya sea por escáneres o por personas. Así que basta con negarse a resolver versiones más recientes que una ventana configurada:
# .cargo/config.toml
[registry]
global-min-publish-age = "3 days"
A partir de ahí, cargo update omite en silencio las releases recientes y te dice lo que ha retenido: clap 4.6.7 (disponible: 4.6.9, publicada hace 2 días). Cuando de verdad necesitas un hotfix, una variable de entorno de un solo uso permite traerlo de forma deliberada, y esa decisión queda registrada en Cargo.lock en lugar de propagarse en silencio. Es de esos controles de seguridad raros que casi no cuestan nada: cambias unos días de frescura por una cuarentena permanente frente a cualquier ataque de paquete zero-day que se detecte rápido. Dado lo que hemos visto en otros registros —el compromiso de LiteLLM en PyPI es una lección reciente de lo rápido que se propaga una release envenenada—, un cooldown es el seguro más barato del ecosistema. Las notas de la release son admirablemente honestas: no es una defensa completa, y cargo install lo esquiva por completo. El soporte de cuarentena y la detección automatizada de releases sospechosas siguen en la hoja de ruta de crates.io. Defensa en profundidad, entregada una capa cada vez.
Higiene de build: dependencias sin usar y colisiones de caché
Dos mejoras de calidad de vida merecen mención porque atacan las dos quejas más habituales en cualquier hilo sobre Rust: los tiempos de compilación y el uso de disco. Primero, Cargo ahora informa directamente de las dependencias sin usar, con un warning que apunta a la línea exacta de tu Cargo.toml. Rustc tiene desde hace tiempo el lint unused_crate_dependencies, pero daba falsos positivos con Cargo porque las dependencias se comparten entre targets de build: una dep usada por un bin de un paquete parece sin usar para otro. Cargo tiene la visión global que le falta a rustc, así que ahora el warning vive donde está la verdad. Se activa al compilar todos los targets relevantes y es el primer ciudadano de un nuevo sistema de lints, [lints.cargo], para el propio manifiesto.
Segundo, se reorganizó el directorio de build. Distintas configuraciones —conjuntos de features, perfiles— producen artefactos distintos, y un hash de configuración los mantiene separados. Ese hash no se aplicaba de forma consistente por restricciones de plataforma, lo que provocaba recompilaciones extra, recompilaciones perdidas y bastante confusión, todo peor si compartías un directorio de build entre worktrees de git. La solución mueve el hash de los nombres de archivo a una estructura de directorios organizada por paso de build. Invisible cuando funciona, que es precisamente el objetivo, y abre la puerta a la recolección de caché y a la deduplicación entre workspaces más adelante. Si tu target/ alguna vez ha devorado 90 gigas y te ha obligado a un cargo clean diario, los cimientos de tu salvación acaban de colocarse. La solución completa todavía no está aquí, pero la refactorización que sostiene el resto, sí.

Lo que enseñan cien releases sobre la evolución de un lenguaje
La estabilidad no es la ausencia de cambios. Es la disciplina de secuenciar los cambios para que el código de nadie pague el precio de tu hoja de ruta.
Da un paso atrás y mira la forma de esta release. Un refinamiento de teoría de tipos que tardó una década. Un trait de allocator deliberadamente lanzado como base, no como superficie terminada. Un modismo de scope guard más antiguo que algunos de sus usuarios, por fin estandarizado. Una característica de seguridad construida sobre metadatos del registro y con advertencias honestas. Internos del sistema de build refactorizados para desbloquear trabajo futuro. Ninguna de estas es un cambio de paradigma llamativo, y juntas constituyen exactamente eso: un lenguaje que sigue ganando profundidad sin cambiar bajo tus pies. Es el mismo interés compuesto silencioso que se ve en el avance poco vistoso de Java, otro ecosistema que descubrió que lo aburrido es una característica.
La maquinaria que hace posible todo esto merece tanto crédito como cualquier característica. El modelo de trenes de seis semanas hace que ninguna estabilización sea nunca una emergencia. Crater —la herramienta que compila prácticamente todo el ecosistema público de crates contra un compilador candidato— convierte la pregunta «¿esto rompe a alguien?» de una plegaria en una medición. Las ediciones ofrecen una ruta de migración opt-in, de modo que el lenguaje puede cambiar sus valores por defecto sin cambiar tu código. Y la relativamente nueva institución de los objetivos de proyecto con nombre (Allocators 1.0, la estructura del directorio de build, el endurecimiento de la cadena de suministro de crates.io) da a los esfuerzos de varios años una columna vertebral pública, de modo que una característica como el tipo never puede fracasar cinco veces y aun así tener un camino designado hacia casa en lugar de morir en un hilo de la lista de correo.
Hay una lección aquí para cualquiera que mantenga una plataforma, un protocolo o una librería muy usada. Los usuarios no experimentan tu hoja de ruta; experimentan tus diffs. Que el tipo never llegue en la 1.100 en lugar de en la 1.35 no es una historia de lentitud: es una historia de lo que pasa cuando un proyecto trata «ya lo sabremos cuando lo veamos» como respuesta aceptable durante una década. La mayoría de las organizaciones de software no pueden permitirse esa paciencia, y, sinceramente, la mayoría no la necesita. Pero si construyes algo sobre lo que otros construyen, la cuenta cambia: la confianza de tus usuarios se compone como el interés, y la única forma de ganarla es con cien releases en las que nada se rompe. Rust 1.100 es una gran release. La historia más grande es que puedes instalarla sin leer antes las notas.


