Rust 2026 经验谈 - trait 系统进阶

1
// 必须用 dyn Trait：不同类型混存
2
let shapes: Vec<Box<dyn Shape>> = vec![
3
    Box::new(Circle { radius: 1.0 }),
4
    Box::new(Square { side: 2.0 }),
5
    Box::new(Circle { radius: 3.0 }),
6
];
7

8
// impl Trait 无法做到——它要求所有元素类型相同
9
// let shapes: Vec<Box<impl Shape>> = ...  // ❌ impl Trait 不允许这样用

1
// ❌ 不能在 let 绑定中使用 impl Trait
2
// let x: impl Shape = Circle { radius: 1.0 };
3

4
// ❌ 不能在结构体字段中使用 impl Trait
5
// struct Container { item: impl Shape }
6

7
// ✅ stable 上主要用于函数签名
8
fn get_shape() -> impl Shape {
9
    Circle { radius: 1.0 }
10
}
11

12
// ⚠️ type alias impl trait (TAIT) 截至 Rust 1.96.0 仍未稳定
13
// type MyShape = impl Shape;

1
// async-trait 宏版本（1.75 之前）
2
#[async_trait::async_trait]
3
trait LegacyService {
4
    async fn fetch(&self, url: &str) -> Result<String, std::io::Error>;
5
}
6

7
// 脱糖后实际签名：
8
// fn fetch<'async_trait>(&'async_trait self, url: &'async_trait str)
9
//     -> Pin<Box<dyn Future<Output = Result<String, std::io::Error>> + 'async_trait>>

1
// 要求返回的 future 是 Send（用于 tokio::spawn）
2
trait AsyncService: Send + Sync {
3
    async fn fetch(&self, url: &str) -> Result<String, std::io::Error>;
4
}
5

6
// 在 spawn 中使用
7
async fn use_service(svc: &dyn AsyncService) {
8
    // ❌ dyn AsyncService 不是 object safe（async fn）
9
    // 需要用泛型参数
10
}

1
// 标准库中：
2
impl<T: !Send> !Send for std::cell::Cell<T> {}
3
// "如果 T 不是 Send，则 Cell<T> 也不是 Send"
4

5
// 你的代码中可能需要：
6
struct MyType(std::cell::Cell<i32>);
7
// MyType 是 Send（Cell<i32> 是 Send，因为 i32: Send）
8
// 但如果你认为它不应该跨线程共享：
9
impl !Sync for MyType {}  // 需要 nightly feature(negative_impls)

1
struct ThreadSafeRc<T> {
2
    inner: std::rc::Rc<std::sync::Mutex<T>>,
3
}
4

5
// Rc 不是 Send，但如果我们保证只在创建线程访问 Rc 本身...
6
// SAFETY: ThreadSafeRc 内部的 Rc 只在创建线程被引用，
7
// 跨线程共享的是 Mutex 保护的数据，通过 Arc 应该更安全。
8
// ⚠️ 实际上这个设计是 unsound 的！Rc 的引用计数不是原子操作，
9
// 跨线程递增/递减引用计数会导致数据竞争。
10
// 正确做法是用 Arc<Mutex<T>>
11
unsafe impl<T: Send> Send for ThreadSafeRc<T> {}  // ❌ 这是 unsound 的！

1
trait Clone2 {
2
    fn clone(&self) -> Self;  // ❌ 返回 Self
3
}
4

5
// 为什么：dyn Clone2 的 Self 是 dyn Clone2 本身，
6
// 但 clone 需要返回具体类型的大小在编译期已知。
7
// dyn Clone2 是胖指针（2 * usize），但具体类型大小未知。

1
trait Processor {
2
    fn process<T>(&self, data: T) -> T;  // ❌ 泛型方法
3
}
4

5
// 为什么：泛型方法需要单态化——每个 T 生成一份代码。
6
// dyn Processor 只有一张虚表，无法容纳无限多的单态化版本。

1
trait ExactSize: Sized {
2
    fn len(&self) -> usize;
3
}
4

5
// ❌ dyn ExactSize 不可能：Sized 要求编译期已知大小，
6
// 而 dyn ExactSize 是胖指针，"指向的对象"大小未知

1
trait Factory {
2
    fn create() -> Self where Self: Sized;  // ✅ 排除在 object 之外
3
    fn name(&self) -> &str;                  // ✅ object safe
4
}
5

6
// dyn Factory 可以调用 name()，但不能调用 create()

1
trait AsyncService {
2
    async fn fetch(&self) -> String;  // ❌ 不 object safe
3
}
4

5
// 原因：async fn 返回匿名 Future 类型，
6
// 等价于 fn fetch(&self) -> impl Future<Output = String>
7
// impl Trait 在返回位置不 object safe

1
trait AsyncServiceDyn {
2
    fn fetch(&self) -> Pin<Box<dyn Future<Output = String> + '_>>;
3
}