Rust Patterns 中文教程

快速参考卡

模式决策指南

需要原语的类型安全？
└── Newtype 模式（第 3 章）

需要编译时状态强制？
└── Type-state 模式（第 3 章）

需要无运行时数据的"标签"？
└── PhantomData（第 4 章）

需要打破 Rc/Arc 引用循环？
└── Weak<T> / sync::Weak<T>（第 8 章）

需要在不 busy-looping 的情况下等待条件？
└── Condvar + Mutex（第 6 章）

需要处理"N 个类型中的一个"？
├── 已知封闭集合 → Enum
├── 开放集合，热路径 → 泛型
├── 开放集合，冷路径 → dyn Trait
└── 完全未知的类型 → Any + TypeId（第 2 章）

需要跨线程共享状态？
├── 简单计数器/标志 → Atomics
├── 短临界区 → Mutex
├── 读多写少 → RwLock
├── 惰性一次性初始化 → OnceLock / LazyLock（第 6 章）
└── 复杂状态 → Actor + Channels

需要并行化计算？
├── 集合处理 → rayon::par_iter
├── 后台任务 → thread::spawn
└── 借用本地数据 → thread::scope

需要 async I/O 或并发网络？
├── 基础 → tokio + async/await（第 15 章）
└── 高级（streams、中间件）→ 参见 Async Rust 培训

需要错误处理？
├── 库 → thiserror（#[derive(Error)]）
└── 应用程序 → anyhow（Result<T>）

需要防止值被 move？
└── Pin<T>（第 8 章）—— Futures、自引用类型所必需

Trait 边界速查表

生命周期省略规则

编译器在三种情况下自动插入生命周期（所以你不必）：

#![allow(unused)]
fn main() {
// 规则 1：每个引用参数获得自己的生命周期
// fn foo(x: &str, y: &str)  →  fn foo<'a, 'b>(x: &'a str, y: &'b str)

// 规则 2：如果只有一个输入生命周期，它用于所有输出
// fn foo(x: &str) -> &str   →  fn foo<'a>(x: &'a str) -> &'a str

// 规则 3：如果一个参数是 &self 或 &mut self，使用它的生命周期
// fn foo(&self, x: &str) -> &str  →  fn foo<'a>(&'a self, x: &str) -> &'a str
}

当你必须编写显式生命周期时：

• 多个输入引用和一个引用输出（编译器无法猜测哪个输入）
• 持有引用的结构体字段：struct Ref<'a> { data: &'a str }
• 当你需要无借用引用的数据时的 'static 边界

常见的 Derive Traits

#![allow(unused)]
fn main() {
#[derive(
    Debug,          // {:?} 格式化
    Clone,          // .clone()
    Copy,           // 隐式 copy（仅用于简单类型）
    PartialEq, Eq,  // == 比较
    PartialOrd, Ord, // < > 比较 + 排序
    Hash,           // HashMap/HashSet 键
    Default,        // Type::default()
)]
struct MyType { /* ... */ }
}

模块可见性快速参考

pub           → 对所有地方可见
pub(crate)    → 在 crate 内可见
pub(super)    → 对父模块可见
pub(in path)  → 在特定路径内可见
(无)          → 对当前模块 + 子模块私有

延伸阅读

Rust 模式和工程实战 完