Rust 1.100.0 Stabilizes 'Never' Type and Custom Allocator APIs

After a decade of development and five failed stabilization attempts, the Rust team has officially stabilized the 'never' type (!) in version 1.100.0. This change allows developers to explicitly represent diverging computations—code that never resolves to a value, such as a function that always returns or exits—enabling more expressive type checking in complex control flows like `match` arms.

The Stabilization of the 'Never' Type

The 'never' type, denoted by the `!` symbol, represents computations that never resolve to a value. While it was previously usable in certain contexts, this release allows it to be named anywhere, including as a generic parameter or a return type.

A key feature of the 'never' type is its ability to coerce into any other type. This allows a `match` arm that performs a `return` to pass type checking even if the other arms return a specific value, as the compiler treats the `return` as a valid transition to the expected type.

This screenshot provides a concrete code example of the newly stabilized 'never' type and its behavior in the language.

To support this, the team changed the 'never type fallback' from `()` to `!` for editions prior to 2024. While this is largely unnoticeable, it may cause the compiler to detect more unreachable code or affect rare cases involving generic parameters.

Custom Allocators and Memory Management

Rust 1.100.0 marks a major milestone for the Allocators 1.0 project by stabilizing the core `Allocator` trait. This enables library authors to define custom memory allocation strategies that can be used directly with standard library types like `Vec` and `Box`.

Chart drawn by HN Digest from figures reported by blog.rust-lang.org; values are shown as written in the source.

While this provides the foundation for custom memory management, the team notes that more work remains to expand the API surface and stabilize these allocators for a wider range of collections and pointer types.

Supply Chain Security and Cargo Improvements

To protect against malicious package releases, Cargo now supports 'dependency cooldowns' via the `global-min-publish-age` configuration. This allows users to specify a minimum age (e.g., 3 days) before Cargo will resolve a newly published version of a dependency.

This image shows the configuration syntax for the 'dependency cooldowns' feature mentioned in the supply chain security section.

The release also introduces automated reporting for unused dependencies in `Cargo.toml`. This helps developers keep their build configurations lean by warning them about crates that are included in the workspace but not utilized by any build targets.

Additionally, Cargo's build directory layout was overhauled to consistently apply build-configuration hashes. This change aims to reduce extra rebuilds and resolve issues where different configurations shared files in a way that caused cache collisions.

New Tools: DropGuard and Conjuring ZSTs

The new `core::mem::DropGuard` helper type simplifies the creation of 'all-or-nothing' APIs. It takes a variable and a closure, running the closure only when the guard is dropped, while providing a `dismiss` method to return the variable without triggering the destructor.

This screenshot illustrates the DropGuard helper type, which simplifies 'all-or-nothing' transaction-like APIs.

For low-level systems programming, the release adds `std::mem::conjure_zst`. This provides a dedicated, unsafe way to create zero-sized types (ZSTs) when the developer knows the operation is safe, replacing various 'incantations' like transmuting `()` or using `MaybeUninit`.