编程 Rust 1.95 深度实战：cfg_select! 宏、let chains 守卫与标准库全面升级，从语言特性到工程落地的完整指南

2026-04-26 13:44:08 +0800 CST views 12

Rust 1.95 深度实战：cfg_select! 宏、let chains 守卫与标准库全面升级，从语言特性到工程落地的完整指南

2026年4月16日，Rust 1.95.0 正式发布。这不是一次小修小补——cfg_select! 宏的稳定化、match if let 守卫、PowerPC 内联汇编、标准库大批 API 稳定，以及编译器和平台支持的全面增强，让这个版本成为 Rust 在跨平台工程和嵌入式场景中的又一座里程碑。本文从语言特性原理讲起，配合大量实战代码，深入每个变更的工程价值。

一、Rust 1.95 发布概览：不只是几个 API

Rust 1.95.0 的分支时间是 2026 年 2 月 27 日，由 Rust Release Team 推出。这个版本的核心更新可以概括为以下几条主线：

语言特性：cfg_select! 宏稳定、match 分支支持 if let 守卫、路径段关键字重命名导入、irrefutable_let_patterns lint 调整
编译器与平台：PowerPC/PowerPC64 内联汇编稳定、Tier 2 平台提升
标准库：大批 API 稳定，const 上下文能力持续扩展
工具链：Rustdoc 体验优化、兼容性变更需重点关注

如果你还在用 Rust 1.80 时代的写法，这篇文章会帮你快速理解：1.95 到底带来了什么，以及怎么在你的项目中立刻用起来。

二、cfg_select! 宏：告别 cfg-if，编译期条件选择的原生解法

2.1 背景：cfg-if 的痛点

在 Rust 1.95 之前，跨平台代码的条件编译几乎都要依赖 cfg-if 这个 crate。看一段典型代码：

// 旧写法：依赖 cfg-if crate
use cfg_if::cfg_if;

cfg_if::cfg_if! {
    if #[cfg(target_os = "linux")] {
        fn platform_init() {
            println!("Linux 初始化");
        }
    } else if #[cfg(target_os = "macos")] {
        fn platform_init() {
            println!("macOS 初始化");
        }
    } else if #[cfg(target_os = "windows")] {
        fn platform_init() {
            println!("Windows 初始化");
        }
    } else {
        fn platform_init() {
            println!("未知平台");
        }
    }
}

这种写法有几个问题：

额外依赖：每个项目都要在 Cargo.toml 里加上 cfg-if，虽然它很轻量，但终究是个外部依赖
语法不够统一：cfg_if! 宏用了 if #[cfg(...)] 的混合语法，跟 Rust 标准的 cfg! 宏风格不一致
嵌套地狱：当条件分支多了，嵌套层级深，代码可读性急剧下降
IDE 支持：第三方宏的语法高亮和补全通常不如内建宏好

2.2 cfg_select! 的设计哲学

cfg_select! 宏的设计目标很简单：在编译期做条件选择，语法风格与 cfg! 宏统一，零外部依赖。

它本质上是一个编译期的 match 表达式——编译器从上到下依次检查每个 if cfg!(...) 条件，第一个匹配 true 的分支会被展开，其余分支直接丢弃。

2.3 基础用法

cfg_select! {
    if cfg!(target_os = "linux") {
        fn platform_init() {
            println!("Linux 初始化");
        }
    } else if cfg!(target_os = "macos") {
        fn platform_init() {
            println!("macOS 初始化");
        }
    } else {
        fn platform_init() {
            println!("其他平台");
        }
    }
}

看起来跟 cfg_if 差不多？区别在于：

不需要任何外部 crate
语法更简洁：直接用 cfg!(...) 而不是 #[cfg(...)]
编译器原生支持，语法高亮、错误提示更友好

2.4 实战场景：跨平台文件系统抽象

来一个更实际的例子——跨平台文件系统操作：

use std::fs;
use std::path::Path;

cfg_select! {
    if cfg!(target_os = "linux") {
        use std::os::linux::fs::MetadataExt;
        
        pub fn get_file_creator(path: &Path) -> Option<u32> {
            fs::metadata(path)
                .ok()
                .map(|m| m.uid())
        }
        
        pub fn is_executable(path: &Path) -> bool {
            fs::metadata(path)
                .map(|m| {
                    let mode = m.mode();
                    mode & 0o111 != 0
                })
                .unwrap_or(false)
        }
    } else if cfg!(target_os = "windows") {
        use std::os::windows::fs::MetadataExt;
        
        pub fn get_file_creator(path: &Path) -> Option<u32> {
            // Windows 使用不同的权限模型
            None
        }
        
        pub fn is_executable(path: &Path) -> bool {
            // Windows 通过文件扩展名判断
            path.extension()
                .map(|ext| matches!(ext.to_str(), Some("exe" | "bat" | "cmd" | "ps1")))
                .unwrap_or(false)
        }
    } else {
        pub fn get_file_creator(_path: &Path) -> Option<u32> {
            None
        }
        
        pub fn is_executable(_path: &Path) -> bool {
            false
        }
    }
}

2.5 实战场景：条件编译与 Feature Gate 结合

cfg_select! 不仅能按平台选择，还能结合 feature flag 使用：

cfg_select! {
    if cfg!(feature = "gpu-cuda") {
        pub mod backend {
            pub fn compute(data: &[f32]) -> Vec<f32> {
                crate::cuda::launch_kernel(data)
            }
        }
    } else if cfg!(feature = "gpu-vulkan") {
        pub mod backend {
            pub fn compute(data: &[f32]) -> Vec<f32> {
                crate::vulkan::dispatch_compute(data)
            }
        }
    } else {
        pub mod backend {
            pub fn compute(data: &[f32]) -> Vec<f32> {
                // CPU fallback：简单向量运算
                data.iter().map(|&x| x * 2.0).collect()
            }
        }
    }
}

在 Cargo.toml 中：

[features]
default = []
gpu-cuda = ["cuda-sys"]
gpu-vulkan = ["vulkan-sys"]

2.6 从 cfg-if 迁移：渐进式替换

对于已有项目，迁移策略很简单：

// 第一步：移除 Cargo.toml 中的 cfg-if 依赖
// [dependencies]
// cfg-if = "0.1"  ← 删除

// 第二步：全局替换
// cfg_if::cfg_if! { → cfg_select! {
// if #[cfg(...)] { → if cfg!(...) {

如果你用了 cargo edit：

cargo rm cfg-if

2.7 cfg_select! 的局限与注意事项

只能用于项（item）级别：不能在函数体内的表达式位置使用
条件必须是编译期常量：cfg!() 里的条件在编译期求值
不支持循环和递归：宏展开是线性的，不能做复杂的编译期计算
与宏的交互：在 cfg_select! 内部定义宏时需要注意卫生性

// ❌ 错误：不能在表达式位置使用
fn foo() {
    let x = cfg_select! {  // 编译错误！
        if cfg!(target_os = "linux") { 1 }
        else { 2 }
    };
}

// ✅ 正确：使用 cfg! 宏在表达式位置
fn foo() {
    let x = if cfg!(target_os = "linux") { 1 } else { 2 };
}

三、match if let 守卫：let chains 的终极形态

3.1 从 if let 到 let chains 的演进

Rust 的模式匹配一直在进化：

Rust 1.0：基本的 if let 和 match
Rust 1.88：稳定了 if let ... && ... 的 let chains 语法
Rust 1.95：let chains 正式进入 match 守卫

这个演进路径的意义在于：match 表达式终于拥有了与 if let 同等强大的条件组合能力。

3.2 语法详解

match value {
    Some(x) if let Ok(y) = x.parse::<i32>() && y > 0 => {
        println!("正整数: {}", y);
    }
    Some(x) if let Ok(y) = x.parse::<i32>() => {
        println!("非正整数: {}", y);
    }
    Some(_) => {
        println!("无法解析为整数");
    }
    None => {
        println!("空值");
    }
}

这里的 if let Ok(y) = x.parse::<i32>() && y > 0 就是一个 let chain：先尝试解析，再判断值是否为正。

3.3 实战场景：协议解析器

在网络协议解析中，经常需要根据数据包的不同字段组合来选择处理路径。let chains 让代码从嵌套地狱变成清晰的线性匹配：

enum Packet {
    Tcp { flags: u8, seq: u32, payload: Vec<u8> },
    Udp { port: u16, payload: Vec<u8> },
    Icmp { ty: u8, code: u8, payload: Vec<u8> },
}

fn handle_packet(packet: Packet) -> Result<(), String> {
    match packet {
        // TCP SYN 包：发起连接
        Packet::Tcp { flags, seq, payload } 
            if flags & 0x02 != 0 && payload.is_empty() => {
            println!("TCP SYN: seq={}", seq);
            Ok(())
        }
        // TCP SYN+ACK 包：确认连接
        Packet::Tcp { flags, seq, payload } 
            if flags & 0x12 != 0 && payload.is_empty() => {
            println!("TCP SYN+ACK: seq={}", seq);
            Ok(())
        }
        // TCP 数据包：含有效载荷
        Packet::Tcp { flags, seq, payload } 
            if flags & 0x08 != 0 && !payload.is_empty() => {
            println!("TCP PSH: seq={}, len={}", seq, payload.len());
            Ok(())
        }
        // UDP DNS 查询
        Packet::Udp { port, payload } if port == 53 && !payload.is_empty() => {
            println!("DNS query: {} bytes", payload.len());
            Ok(())
        }
        // UDP DNS 响应
        Packet::Udp { port, payload } if port == 53 => {
            println!("DNS response (empty)");
            Ok(())
        }
        // ICMP Echo Request（ping）
        Packet::Icmp { ty, code, .. } if ty == 8 && code == 0 => {
            println!("ICMP Echo Request");
            Ok(())
        }
        // ICMP Echo Reply
        Packet::Icmp { ty, code, .. } if ty == 0 && code == 0 => {
            println!("ICMP Echo Reply");
            Ok(())
        }
        _ => Err("未知或未处理的包类型".into()),
    }
}

对比旧写法（嵌套 match 或 if-else 链），这种写法的优势一目了然：

// 旧写法：深层嵌套
fn handle_packet_old(packet: Packet) -> Result<(), String> {
    match packet {
        Packet::Tcp { flags, seq, payload } => {
            if flags & 0x02 != 0 {
                if payload.is_empty() {
                    println!("TCP SYN: seq={}", seq);
                    Ok(())
                } else {
                    // SYN 不该带 payload，异常处理
                    Err("SYN with payload".into())
                }
            } else if flags & 0x12 != 0 {
                // ... 继续嵌套
                todo!()
            } else {
                todo!()
            }
        }
        _ => todo!(),
    }
}

3.4 实战场景：配置验证与默认值填充

struct ServerConfig {
    host: Option<String>,
    port: Option<u16>,
    tls_cert: Option<String>,
    tls_key: Option<String>,
    max_connections: Option<usize>,
    timeout_secs: Option<u64>,
}

fn validate_and_build(config: ServerConfig) -> Result<Server, ConfigError> {
    match config {
        // 完整 TLS 配置
        ServerConfig { 
            host: Some(h), 
            port: Some(p), 
            tls_cert: Some(cert), 
            tls_key: Some(key), 
            max_connections: Some(max),
            timeout_secs: Some(t),
        } => Ok(Server::new_tls(&h, p, &cert, &key, max, t)),
        
        // 部分配置：有 TLS 证书但没有密钥
        ServerConfig { 
            host: Some(h), 
            port: Some(p), 
            tls_cert: Some(_), 
            tls_key: None, 
            .. 
        } => Err(ConfigError::MissingTlsKey),
        
        // HTTP 模式（无 TLS）
        ServerConfig { 
            host: Some(h), 
            port: Some(p), 
            tls_cert: None, 
            tls_key: None, 
            max_connections,
            timeout_secs,
        } => Ok(Server::new_http(
            &h, 
            p, 
            max_connections.unwrap_or(1000),
            timeout_secs.unwrap_or(30),
        )),
        
        // 缺少必填字段
        ServerConfig { host: None, .. } => Err(ConfigError::MissingHost),
        ServerConfig { port: None, .. } => Err(ConfigError::MissingPort),
    }
}

3.5 let chains 在 match 中的性能考量

一个常见的疑问：let chains 会不会引入运行时开销？

答案：不会。if let 守卫在编译后就是普通的分支判断，match 的穷尽性检查（exhaustiveness check）依然在编译期完成。let chains 只是把多个条件组合成一个守卫表达式，编译器的优化器会正常处理。

用 cargo asm 验证：

// 源码
pub fn parse_and_check(s: Option<&str>) -> i32 {
    match s {
        Some(x) if let Ok(y) = x.parse::<i32>() && y > 0 => y,
        _ => -1,
    }
}

// 编译后的汇编（x86_64, --release）
// 可以看到就是简单的条件跳转，没有额外开销

四、路径段关键字重命名导入：模块系统的灵活性提升

4.1 问题背景

Rust 保留了少量关键字用于特殊用途（如 async、type、fn），但在某些 FFI 场景或动态生成的模块中，这些关键字可能出现在路径段中。Rust 1.95 之前，直接导入这些路径会编译报错。

4.2 新语法

// 假设有一个 C 库通过 bindgen 生成的模块，包含关键字路径
mod generated {
    pub mod r#async {
        pub fn runtime() -> &'static str {
            "native-async-runtime"
        }
    }
    pub mod r#type {
        pub fn descriptor() -> &'static str {
            "type-descriptor"
        }
    }
}

// Rust 1.95：可以直接导入并重命名
use generated::r#async as async_mod;
use generated::r#type as type_mod;

fn main() {
    println!("{}", async_mod::runtime());    // "native-async-runtime"
    println!("{}", type_mod::descriptor());  // "type-descriptor"
}

4.3 实战场景：WASM 绑定生成

在使用 wasm-bindgen 或 js-sys 时，JavaScript 的保留字经常出现在生成的绑定中：

use js_sys::r#Promise as JsPromise;
use js_sys::r#function as JsFunction;

async fn call_js_async(promise: JsPromise) -> Result<JsValue, JsValue> {
    let result = JsPromise::then(&promise, &JsFunction::new_no_args(|| {
        js_sys::Reflect::get(&js_sys::global(), &"console".into())
            .ok()
            .and_then(|c| js_sys::Reflect::get(&c, &"log".into()).ok())
    }))?;
    Ok(result)
}

五、PowerPC 内联汇编稳定：嵌入式与高性能计算的新选择

5.1 为什么 PowerPC 内联汇编重要

PowerPC 架构在以下领域依然活跃：

游戏机：PlayStation 3 的 Cell 处理器
嵌入式：汽车电子、工业控制
高性能计算：某些超算节点
网络设备：路由器、交换机的主控芯片

Rust 1.95 稳定了 PowerPC 和 PowerPC64 的内联汇编支持，这意味着你可以直接在 Rust 代码中编写 PowerPC 汇编，不再需要单独的 .s 文件或外部汇编器。

5.2 基础用法

use std::arch::asm;

// PowerPC：读取 Time Base 寄存器（高性能计时器）
#[cfg(target_arch = "powerpc64")]
fn read_time_base() -> u64 {
    let tb: u64;
    unsafe {
        asm!(
            "mftb {0}",
            out(reg) tb,
        );
    }
    tb
}

// PowerPC：缓存刷新指令
#[cfg(target_arch = "powerpc64")]
fn cache_flush(addr: *const u8) {
    unsafe {
        asm!(
            "dcbf 0, {0}",
            in(reg) addr,
        );
    }
}

// PowerPC：内存屏障
#[cfg(target_arch = "powerpc64")]
fn memory_barrier() {
    unsafe {
        asm!("sync");
    }
}

5.3 实战场景：嵌入式 PowerPC 中断处理

#[cfg(target_arch = "powerpc")]
fn enable_interrupts() {
    unsafe {
        asm!(
            "mfmsr {0}",
            "ori {0}, {0}, 0x8000",  // 设置 EE 位
            "mtmsr {0}",
            out(reg) _,
        );
    }
}

#[cfg(target_arch = "powerpc")]
fn disable_interrupts() -> u32 {
    let msr: u32;
    unsafe {
        asm!(
            "mfmsr {0}",
            "andi. {0}, {0}, 0x7FFF",  // 清除 EE 位
            "mtmsr {0}",
            out(reg) msr,
        );
    }
    msr
}

六、标准库 API 稳定化：const 扩展与常用接口

6.1 const 上下文能力扩展

Rust 一直在稳步推进 const 上下文的能力边界。1.95 版本中，更多函数可以在 const fn 中使用，这意味着更多的计算可以在编译期完成。

// 之前只能在运行期做的，现在可以在编译期做了
const MAX_BUFFER_SIZE: usize = 1024 * 1024;  // 1MB

// 编译期验证
const fn validate_buffer_size(size: usize) -> usize {
    assert!(size > 0, "buffer size must be positive");
    assert!(size <= MAX_BUFFER_SIZE, "buffer too large");
    size
}

const BUFFER_SIZE: usize = validate_buffer_size(4096);

// 编译期字符串处理
const fn hash_string(s: &str) -> u64 {
    let mut hash: u64 = 5381;
    let bytes = s.as_bytes();
    let mut i = 0;
    while i < bytes.len() {
        hash = hash.wrapping_mul(33).wrapping_add(bytes[i] as u64);
        i += 1;
    }
    hash
}

const COMMAND_HASH: u64 = hash_string("SET");
const GET_HASH: u64 = hash_string("GET");
const DELETE_HASH: u64 = hash_string("DELETE");

6.2 新稳定 API 速览

以下是 Rust 1.95 稳定的重要标准库 API（不完全列表）：

// 1. slice::split_at_mut_checked — 安全的分割
fn process_buffer(buf: &mut [u8]) {
    if let Some((header, body)) = buf.split_at_mut_checked(4) {
        header[0] = 0x89;  // PNG magic byte
        process_body(body);
    } else {
        // 缓冲区太小，优雅降级
        eprintln!("buffer too small");
    }
}

fn process_body(body: &mut [u8]) {
    // 处理消息体
}

// 2. 指数运算增强
fn compute_scaling_factors() -> [f64; 8] {
    let mut factors = [0.0; 8];
    for (i, f) in factors.iter_mut().enumerate() {
        *f = 2.0_f64.powi(i as i32);
    }
    factors
}

// 3. Option 的更多便捷方法
fn find_user(id: u32) -> Option<String> {
    let db_result: Result<Option<String>, String> = query_db(id);
    
    // 使用新的组合方法链
    db_result
        .ok()
        .flatten()
        .or_else(|| get_from_cache(id))
        .filter(|name| !name.is_empty())
}

fn query_db(id: u32) -> Result<Option<String>, String> {
    if id == 0 { Err("invalid id".into()) } else { Ok(Some(format!("user_{}", id))) }
}
fn get_from_cache(id: u32) -> Option<String> {
    if id < 100 { Some(format!("cached_{}", id)) } else { None }
}

6.3 PollFn 的 Unpin 变更

一个重要的兼容性变更：PollFn 现在只有在闭包是 Unpin 的时候才实现 Unpin。

use std::future::poll_fn;
use std::task::Poll;

// Rust 1.94 及之前：PollFn 总是 Unpin
// Rust 1.95：PollFn 只在闭包是 Unpin 时才 Unpin

async fn example() {
    let mut captured = String::from("hello");
    
    // 如果闭包捕获了 &mut captured，那么闭包不是 Unpin
    // 相应地，PollFn 也不是 Unpin
    let future = poll_fn(|_cx| {
        captured.push_str(" world");
        Poll::Ready(captured.clone())
    });
    
    let result = future.await;
    println!("{}", result);
}

如果你之前的代码依赖 PollFn: Unpin 的自动推导，升级后可能需要调整。

七、irrefutable_let_patterns lint 调整：减少噪音

7.1 变更说明

irrefutable_let_patterns lint 之前会对 let chains 中的不可反驳模式发出警告，即使这些模式在逻辑上是合理的。1.95 版本中，这个 lint 不再对 let chains 发出提示。

7.2 影响

// 之前：这段代码会触发 irrefutable_let_patterns 警告
if let x = some_value && let Some(y) = x.parse() {
    // 1.94 及之前：warning: irrefutable let pattern
    // 1.95：不再警告
    println!("parsed: {}", y);
}

这个调整是合理的——在 let chains 中，前面的不可反驳模式只是为了绑定变量给后续条件使用，并不是逻辑错误。

八、Rustdoc 体验优化

8.1 主要改进

Rust 1.95 对文档生成工具 Rustdoc 做了多项改进：

搜索体验优化：支持按类型签名搜索，不再只匹配名称
文档链接验证：更严格的 intra-doc link 校验
渲染性能：大型 crate 的文档生成速度提升

8.2 实际影响

对于库作者来说，这意味着：

用户更容易通过类型签名找到需要的 API
文档中的死链接会被更早发现
CI 中 cargo doc 的耗时缩短

# Cargo.toml — 启用更严格的文档检查
[package.metadata.docs.rs]
rustdoc-args = ["--cfg", "docsrs"]

九、兼容性变更：升级前必读

9.1 可能影响现有代码的变更

变更项	影响	应对措施
PollFn Unpin 变更	依赖 PollFn: Unpin 的代码可能编译失败	检查 Pin 相关代码
irrefutable_let_patterns	警告减少，但行为变化	运行 `cargo clippy` 检查
导入路径关键字	可能有新的名称冲突	使用 `as` 重命名
最小 Rust 版本提升	某些平台的支持等级变化	检查目标平台

9.2 升级步骤

# 1. 更新工具链
rustup update stable

# 2. 检查项目
cargo check
cargo test
cargo clippy

# 3. 处理编译警告和错误
# 重点关注 PollFn 相关的 Unpin 问题

# 4. 享受新特性
# 逐步将 cfg-if 替换为 cfg_select!
# 在 match 中使用 if let 守卫

十、从 1.80 到 1.95：Rust 语言进化趋势分析

10.1 模式匹配的持续增强

从 Rust 1.80 到 1.95，模式匹配是持续增强的核心方向：

版本	模式匹配增强
1.80	if let chains（nightly）
1.85	if let chains 稳定
1.88	let chains 进入 if 表达式
1.94	6 倍编译提速（间接提升模式匹配编译速度）
1.95	let chains 进入 match 守卫、cfg_select!

趋势很明显：Rust 在让模式匹配越来越强大和自然，从嵌套地狱走向线性表达。

10.2 编译速度的持续改善

Rust 长期被诟病的编译速度问题正在逐步解决：

1.94：6 倍编译提速（Eddy 后端改进）
1.95：持续的基础设施优化
下游效应：大型项目的增量编译时间大幅缩短

10.3 嵌入式与系统编程的加强

PowerPC 内联汇编稳定、RISC-V 特性持续稳定化——Rust 在嵌入式和系统编程领域的覆盖面越来越广。这不仅是硬件平台支持的增加，更是 Rust 对「替代 C/C++」这个目标的坚定推进。

十一、实战项目：跨平台日志库

让我们把 1.95 的主要特性串起来，写一个跨平台的日志库：

// lib.rs
#![allow(unused)]

use std::fmt;
use std::fs::File;
use std::io::Write;
use std::path::Path;
use std::sync::Mutex;
use std::time::Instant;

/// 日志级别
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Level {
    Trace,
    Debug,
    Info,
    Warn,
    Error,
}

impl fmt::Display for Level {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Level::Trace => write!(f, "TRACE"),
            Level::Debug => write!(f, "DEBUG"),
            Level::Info => write!(f, " INFO"),
            Level::Warn => write!(f, " WARN"),
            Level::Error => write!(f, "ERROR"),
        }
    }
}

/// 日志输出目标
enum LogTarget {
    Stdout,
    File(Mutex<File>),
    Syslog,
}

/// 跨平台日志记录器
pub struct Logger {
    level: Level,
    target: LogTarget,
    start: Instant,
}

impl Logger {
    /// 创建新日志记录器
    cfg_select! {
        if cfg!(target_os = "linux") {
            pub fn new(level: Level) -> Self {
                Self {
                    level,
                    target: LogTarget::Syslog,
                    start: Instant::now(),
                }
            }
            
            pub fn with_file(path: &Path, level: Level) -> std::io::Result<Self> {
                let file = File::create(path)?;
                Ok(Self {
                    level,
                    target: LogTarget::File(Mutex::new(file)),
                    start: Instant::now(),
                })
            }
        } else {
            pub fn new(level: Level) -> Self {
                Self {
                    level,
                    target: LogTarget::Stdout,
                    start: Instant::now(),
                }
            }
            
            pub fn with_file(path: &Path, level: Level) -> std::io::Result<Self> {
                let file = File::create(path)?;
                Ok(Self {
                    level,
                    target: LogTarget::File(Mutex::new(file)),
                    start: Instant::now(),
                })
            }
        }
    }
    
    /// 记录日志 — 使用 match if let 守卫
    pub fn log(&self, level: Level, module: &str, msg: &str) {
        match level {
            // 错误级别：始终输出并触发告警
            l if l >= Level::Error && l >= self.level => {
                self.write_log(level, module, msg);
                self.trigger_alert(module, msg);
            }
            // 警告级别：输出并在生产环境触发通知
            l if l >= Level::Warn && l >= self.level => {
                self.write_log(level, module, msg);
                cfg_select! {
                    if cfg!(debug_assertions) {
                        // 开发环境：只记录
                    } else {
                        // 生产环境：额外通知
                        self.send_notification(module, msg);
                    }
                }
            }
            // 其他级别：正常输出
            l if l >= self.level => {
                self.write_log(level, module, msg);
            }
            _ => {}
        }
    }
    
    fn write_log(&self, level: Level, module: &str, msg: &str) {
        let elapsed = self.start.elapsed();
        let output = format!(
            "[{:>6?}] [{:>5}] [{}] {}\n",
            elapsed, level, module, msg
        );
        
        match &self.target {
            LogTarget::Stdout => {
                print!("{}", output);
            }
            LogTarget::File(file) => {
                if let Ok(mut f) = file.lock() {
                    let _ = f.write_all(output.as_bytes());
                }
            }
            LogTarget::Syslog => {
                // Linux syslog 输出
                #[cfg(target_os = "linux")]
                {
                    // 实际项目中使用 syslog crate
                    print!("[SYSLOG] {}", output);
                }
                #[cfg(not(target_os = "linux"))]
                {
                    print!("{}", output);
                }
            }
        }
    }
    
    fn trigger_alert(&self, module: &str, msg: &str) {
        eprintln!("🚨 ALERT: [{}] {}", module, msg);
    }
    
    fn send_notification(&self, module: &str, msg: &str) {
        // 发送通知到监控系统
        eprintln!("📢 NOTIFY: [{}] {}", module, msg);
    }
}

/// 便捷宏
#[macro_export]
macro_rules! log_info {
    ($logger:expr, $module:expr, $($arg:tt)*) => {
        $logger.log($crate::Level::Info, $module, &format!($($arg)*))
    };
}

#[macro_export]
macro_rules! log_error {
    ($logger:expr, $module:expr, $($arg:tt)*) => {
        $logger.log($crate::Level::Error, $module, &format!($($arg)*))
    };
}

#[macro_export]
macro_rules! log_warn {
    ($logger:expr, $module:expr, $($arg:tt)*) => {
        $logger.log($crate::Level::Warn, $module, &format!($($arg)*))
    };
}

使用示例：

use my_logger::{Logger, Level};

fn main() {
    let logger = Logger::new(Level::Debug);
    
    log_info!(&logger, "main", "应用启动");
    log_warn!(&logger, "network", "连接超时，正在重试");
    log_error!(&logger, "db", "无法连接数据库: Connection refused");
}

十二、性能优化：利用新特性写出更快的代码

12.1 编译期计算减少运行时开销

// 利用 const fn 在编译期预计算查找表
const fn build_crc32_table() -> [u32; 256] {
    let mut table = [0u32; 256];
    let mut i = 0;
    while i < 256 {
        let mut crc = i as u32;
        let mut j = 0;
        while j < 8 {
            if crc & 1 != 0 {
                crc = (crc >> 1) ^ 0xEDB88320;
            } else {
                crc >>= 1;
            }
            j += 1;
        }
        table[i] = crc;
        i += 1;
    }
    table
}

// 编译期生成，零运行时初始化开销
const CRC32_TABLE: [u32; 256] = build_crc32_table();

pub fn crc32(data: &[u8]) -> u32 {
    let mut crc = 0xFFFFFFFFu32;
    for &byte in data {
        let index = ((crc ^ byte as u32) & 0xFF) as usize;
        crc = (crc >> 8) ^ CRC32_TABLE[index];
    }
    !crc
}

12.2 cfg_select! 消除运行时分发

// 旧写法：运行时判断平台
fn get_temp_dir() -> PathBuf {
    if cfg!(target_os = "linux") {
        // 但 cfg! 在编译期就是常量，这里的分支会被优化掉
        // 不过代码仍然要编译两个分支
    }
}

// 新写法：cfg_select! 完全不编译不相关的分支
cfg_select! {
    if cfg!(target_os = "linux") {
        pub fn get_temp_dir() -> std::path::PathBuf {
            std::path::PathBuf::from("/tmp")
        }
    } else if cfg!(target_os = "macos") {
        pub fn get_temp_dir() -> std::path::PathBuf {
            std::env::var("TMPDIR")
                .map(std::path::PathBuf::from)
                .unwrap_or_else(|_| std::path::PathBuf::from("/tmp"))
        }
    } else if cfg!(target_os = "windows") {
        pub fn get_temp_dir() -> std::path::PathBuf {
            std::env::var("TEMP")
                .map(std::path::PathBuf::from)
                .unwrap_or_else(|_| std::path::PathBuf::from("C:\\Temp"))
        }
    } else {
        pub fn get_temp_dir() -> std::path::PathBuf {
            std::path::PathBuf::from("/tmp")
        }
    }
}

优势：不相关平台的代码完全不会编译，减少了编译时间和二进制体积。

12.3 match if let 守卫避免中间分配

// 旧写法：先 parse 再 match，有中间分配
fn handle_command_old(cmd: &str) -> Result<Action, String> {
    let parts: Vec<&str> = cmd.split_whitespace().collect();
    match parts.as_slice() {
        ["SET", key, value] => Ok(Action::Set(key.to_string(), value.to_string())),
        ["GET", key] => Ok(Action::Get(key.to_string())),
        _ => Err("unknown command".into()),
    }
}

// 新写法：match if let 守卫，减少不必要的分配
fn handle_command(cmd: &str) -> Result<Action, String> {
    let mut parts = cmd.split_whitespace();
    
    match parts.next() {
        Some("SET") if let (Some(key), Some(value)) = (parts.next(), parts.next()) => {
            Ok(Action::Set(key.to_string(), value.to_string()))
        }
        Some("GET") if let Some(key) = parts.next() => {
            Ok(Action::Get(key.to_string()))
        }
        Some("DEL") if let Some(key) = parts.next() => {
            Ok(Action::Delete(key.to_string()))
        }
        Some("MGET") => {
            let keys: Vec<String> = parts.map(String::from).collect();
            if keys.is_empty() {
                Err("MGET requires at least one key".into())
            } else {
                Ok(Action::MultiGet(keys))
            }
        }
        Some(cmd) => Err(format!("unknown command: {}", cmd)),
        None => Err("empty command".into()),
    }
}

#[derive(Debug)]
enum Action {
    Set(String, String),
    Get(String),
    Delete(String),
    MultiGet(Vec<String>),
}

十三、常见陷阱与最佳实践

13.1 cfg_select! 的常见错误

// ❌ 错误：忘了 else 分支，某些平台可能没有定义函数
cfg_select! {
    if cfg!(target_os = "linux") {
        fn init() { /* ... */ }
    } else if cfg!(target_os = "macos") {
        fn init() { /* ... */ }
    }
    // 如果在 Windows 上编译，init() 不存在！
}

// ✅ 正确：总是提供 fallback
cfg_select! {
    if cfg!(target_os = "linux") {
        fn init() { /* Linux 专用初始化 */ }
    } else if cfg!(target_os = "macos") {
        fn init() { /* macOS 专用初始化 */ }
    } else {
        fn init() { /* 通用初始化 */ }
    }
}

13.2 match if let 守卫的穷尽性

// ⚠️ 注意：if let 守卫不影响穷尽性检查
// 编译器仍然要求 match 的模式本身是穷尽的

enum Result<T, E> {
    Ok(T),
    Err(E),
}

fn process(res: Result<i32, String>) {
    match res {
        // 守卫只筛选匹配到的分支
        Result::Ok(x) if x > 0 => println!("正数: {}", x),
        Result::Ok(x) => println!("非正数: {}", x),  // 必须处理剩余情况
        Result::Err(e) => println!("错误: {}", e),
    }
}

13.3 PowerPC 汇编的安全规范

// ❌ 危险：修改关键寄存器可能破坏程序状态
unsafe {
    asm!("li 1, 0");  // 破坏栈指针！
}

// ✅ 正确：使用 out(reg) 让编译器分配寄存器
unsafe {
    let result: u32;
    asm!(
        "addi {0}, {0}, 1",
        inout(reg) 0 => result,
    );
}

十四、总结与展望

Rust 1.95 是一个「让正确的做法变成最简单的做法」的版本：

cfg_select! 消除了对 cfg-if 的依赖，让跨平台条件编译回归标准库
match if let 守卫 让复杂模式匹配从嵌套走向扁平，代码可读性大幅提升
PowerPC 内联汇编 打开了嵌入式和高性能计算的新场景
const 扩展 让更多计算可以前移到编译期
标准库 API 稳定化 让常用操作不再需要第三方依赖

展望未来，Rust 社区正在推进的几个方向值得持续关注：

async fn in traits：异步特性的完整支持
impl Trait 更灵活的位置：在更多地方使用不透明类型
编译速度持续优化：cranelift 后端、增量编译改进
嵌入式生态：更多架构的内联汇编、更完善的 no_std 支持

如果你还没升级，现在就是好时机。1.95 不是终点，但它让 Rust 的工程表达力又上了一个台阶。

rustup update stable
# Welcome to Rust 1.95.0

参考资源
Rust 1.95.0 Release Notes
cfg_select! RFC
let chains stabilization
PowerPC inline asm