Rust 1.95.0: Enhancing Conditional Compilation and Pattern Matching

By

Introduction

The Rust team is proud to announce the release of version 1.95.0, a significant update that brings powerful new tools for compile-time configuration and pattern matching. This release is part of Rust's ongoing commitment to providing a safe, concurrent, and practical language for systems programming. To update your existing installation via rustup, simply run:

Rust 1.95.0: Enhancing Conditional Compilation and Pattern Matching
Source: blog.rust-lang.org
rustup update stable

If you don't have Rust installed yet, visit the official installation page to get started. For those interested in testing upcoming features, you can switch to the beta or nightly channels using rustup default beta or rustup default nightly. Please report any bugs you encounter through the issue tracker.

Key Enhancements in Rust 1.95.0

The cfg_select! Macro

One of the standout features in this release is the cfg_select! macro, which acts as a compile-time conditional selector. It fulfills a role similar to the popular cfg-if crate but with its own syntax. The macro evaluates configuration predicates and expands to the right-hand side of the first arm that evaluates to true. Here's an example:

cfg_select! {
    unix => {
        fn foo() { /* unix specific functionality */ }
    }
    target_pointer_width = "32" => {
        fn foo() { /* non-unix, 32-bit functionality */ }
    }
    _ => {
        fn foo() { /* fallback implementation */ }
    }
}

let is_windows_str = cfg_select! {
    windows => "windows",
    _ => "not windows",
};

This macro simplifies conditional compilation by allowing more complex, readable conditionals than what #[cfg()] attributes alone can provide. It's especially useful for codebases that need to support multiple platforms or configurations.

If-Let Guards in Match Expressions

Building on the stabilization of let chains in Rust 1.88, version 1.95.0 extends this capability to match expressions. Developers can now use if let guards to add pattern-matching conditions directly inside match arms. For example:

match value {
    Some(x) if let Ok(y) = compute(x) => {
        // Both `x` and `y` are available here
        println!("{}, {}", x, y);
    }
    _ => {}
}

It's important to note that the compiler does not currently treat patterns in these guards as part of exhaustiveness checking, similar to how if guards work. This feature enhances expressiveness and reduces the need for nested matches or auxiliary functions.

Stabilized APIs

Rust 1.95.0 stabilizes a wide range of APIs that improve type conversions, atomic operations, and collection methods. Below is the complete list:

These additions enhance safety and convenience, particularly around uninitialized memory handling, atomic operations, and mutable access to collection elements.

Conclusion

Rust 1.95.0 is a solid step forward, offering more control over conditional compilation with cfg_select! and more expressive pattern matching with if-let guards in match expressions. The stabilized APIs further enrich the standard library. Be sure to update your toolchain to experience these improvements firsthand. For a complete list of changes, consult the official release notes.

Tags:

Related Articles

Recommended

Discover More

Orton-Gillingham in Action: A Step-by-Step Guide for Boosting English Learner LiteracyInside Installer No. 126: The Verge's Ruthless Self-Promotion Week and What We're Building8 Crucial Insights into SPIFFE: Protecting Non-Human Identities in the Age of Agentic AI5 Key Insights into the TCLBANKER Banking Trojan Threat10 Key Highlights from the LWN.net Weekly Edition (April 30, 2026)