泛型、trait 与 dyn

它在解决什么

这一章一路在用泛型 —— Option<T>、Result<T, E>、Vec<T> —— 却一直没解释它。这一篇补上，顺带回答那个从 Java/C# 过来的人一定会问的问题： Rust 的 trait 是接口吗？

不完全是。接口通常回答「这个对象是什么」，而 trait 回答 「这个类型能做什么」。差别看起来很虚，但它带来一个很实在的后果： 你可以给一个早就写好的类型补上新能力，包括别人写的类型。

泛型 + trait bound：一份代码，编译期长成多份

fn greet<T: Greet>(x: &T) -> String {
    x.hello()
}

<T: Greet> 读作「任何实现了 Greet 的类型」。 给它传 Cat 和 Dog 都行， 传一个没实现 Greet 的类型就是 E0277。

关键在于这份代码在编译期会被单态化（monomorphization）： 编译器为每个真正用到的 T 各生成一份机器码。所以

• 运行时没有任何查表开销，和你手写两个函数一样快；
• 代价是编译产物变大、编译变慢 —— 泛型用得越狠，这两样越明显。

📌 这就是「零成本抽象」在这里的具体含义：抽象发生在编译期，运行时不留痕迹。

🚨 什么时候不得不用 dyn

单态化有一个硬边界：它要求编译期就知道具体类型。 于是这段代码编译不过：

let zoo = vec![Cat, Dog];    // E0308

Vec<T> 里每个元素必须是同一个 T， 而 Cat 和 Dog 是两个类型。泛型在这里救不了你 —— 无论怎么写 <T: Greet>，那个 T 都只能是一个类型。

改成 Vec<Box<dyn Greet>> 就通了：

let zoo: Vec<Box<dyn Greet>> = vec![Box::new(Cat), Box::new(Dog)];

dyn Greet 的意思是「某个实现了 Greet 的东西，具体是谁运行时才知道」。 它靠一张虚表（vtable）在运行时找到该调哪个 hello。

⇒ 判据很清楚：能用泛型就用泛型；需要在一个集合里混装不同类型时，才换 dyn。

代价是两样：多一次指针跳转（查虚表），以及 Box 带来的一次堆分配。 在绝大多数应用里这点开销无所谓 —— 但它确实不是零。

dyn 的代价之二：不是所有 trait 都能做成它

这个 trait 就不行：

trait Spawn {
    fn make() -> Self;
}

make 没有 self 参数，而且返回 Self。通过一个 dyn Spawn 调它时， 编译器不知道该造出哪种东西，也没有对象可以查虚表 —— 报 E0038。

这类 trait 叫「不是对象安全的」（object safe）。完整规则挺细， 但有个够用的经验：

方法带 &self、不返回 Self、方法本身不带泛型参数，基本就能做 dyn。

不用 dyn、直接写具体类型就没事 —— 对象安全是 dyn 的要求，不是 trait 本身的毛病。

默认方法：用必需的拼出便利的

trait 里的方法可以带默认实现：

trait Greet {
    fn name(&self) -> String;          // 必需

    fn hello(&self) -> String {        // 有默认实现
        format!("你好，{}", self.name())
    }
}

Cat 不写 hello 也能用，Dog 写了就覆盖掉。 但 name 没有默认实现，不写就是 E0046， 而且编译器会点名还差哪几个。

⭐ 这个机制在标准库里用到了极致：Iterator 只要求你实现 next， map / filter / take / zip 那七十多个方法全是拿 next 拼出来的默认方法。

derive：让编译器替你写 impl

{:?} 要 Debug、.clone() 要 Clone、== 要 PartialEq —— 这三样都不是语言内置的，全是 trait。

#[derive(Debug, Clone, PartialEq)]
struct Point { x: i32, y: i32 }

derive 只是按字段逐个生成一份最直白的实现。 整行删掉，那三个操作就全没了。

⇒ 所以「为什么我的结构体不能 println!("{:?}")」的答案永远是同一个： 你没给它那个能力。

孤儿规则，以及 newtype 的又一次登场

trait 最诱人的能力是「给别人的类型补能力」。但它有一条边界：

trait 和类型，至少有一个得是你自己的。

给 Vec<i32> 实现 Display 就是 E0117 —— 两边都是标准库的。

这条规则叫孤儿规则，理由很实际：如果谁都能给别人的类型实现别人的 trait， 两个 crate 各写一份，编译器就不知道该用哪个了。

绕开的办法是包一层 newtype：

struct MyVec(Vec<i32>);
impl fmt::Display for MyVec { /* ... */ }

MyVec 是你的类型，于是随便实现。这也是 newtype 在真实代码里最常见的用途之一 —— 它不只是防呆，还是绕开孤儿规则的标准手法。

这一章到这里就完整了

下一步

前两章讲的是怎么写对。接下来换一个层面：怎么把代码组织成一个能维护的项目 —— 从《模块、crate 与 workspace》开始。

全部篇目见 Rust 教程首页。

trait Greet {
    fn hello(&self) -> String;
}

struct Cat;
struct Dog;

impl Greet for Cat {
    fn hello(&self) -> String { String::from("喵") }
}

impl Greet for Dog {
    fn hello(&self) -> String { String::from("汪") }
}

fn greet<T: Greet>(x: &T) -> String {
    x.hello()
}

fn main() {
    println!("{} {}", greet(&Cat), greet(&Dog));
}

trait Greet {
    fn hello(&self) -> String;
}

struct Cat;
struct Fish;

impl Greet for Cat {
    fn hello(&self) -> String { String::from("喵") }
}

fn greet<T: Greet>(x: &T) -> String {
    x.hello()
}

fn main() {
    println!("{} {}", greet(&Cat), greet(&Fish));
}

trait Greet {
    fn hello(&self) -> String;
}

struct Cat;
struct Dog;

impl Greet for Cat {
    fn hello(&self) -> String { String::from("喵") }
}

impl Greet for Dog {
    fn hello(&self) -> String { String::from("汪") }
}

fn main() {
    let zoo = vec![Cat, Dog];
    for a in &zoo {
        println!("{}", a.hello());
    }
}

error[E0308]: mismatched types
  --> trait-dyn-for-mixed-container.rs:17:25
   |
17 |     let zoo = vec![Cat, Dog];
   |                         ^^^ expected `Cat`, found `Dog`

trait Greet {
    fn hello(&self) -> String;
}

struct Cat;
struct Dog;

impl Greet for Cat {
    fn hello(&self) -> String { String::from("喵") }
}

impl Greet for Dog {
    fn hello(&self) -> String { String::from("汪") }
}

fn main() {
    let zoo: Vec<Box<dyn Greet>> = vec![Box::new(Cat), Box::new(Dog)];
    for a in &zoo {
        println!("{}", a.hello());
    }
}

trait Spawn {
    fn make() -> Self;
}

struct Cat;

impl Spawn for Cat {
    fn make() -> Self { Cat }
}

fn main() {
    let _x: Box<dyn Spawn> = Box::new(Cat::make());
    println!("ok");
}

error[E0038]: the trait `Spawn` is not dyn compatible
  --> trait-object-safety.rs:12:21
   |
12 |     let _x: Box<dyn Spawn> = Box::new(Cat::make());
   |                     ^^^^^ `Spawn` is not dyn compatible
   |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
  --> trait-object-safety.rs:2:8
   |
 1 | trait Spawn {
   |       ----- this trait is not dyn compatible...
 2 |     fn make() -> Self;
   |        ^^^^ ...because associated function `make` has no `self` parameter
   = help: only type `Cat` implements `Spawn`; consider using it directly instead.
help: consider turning `make` into a method by giving it a `&self` argument
   |
 2 |     fn make(&self) -> Self;
   |             +++++
help: alternatively, consider constraining `make` so it does not apply to trait objects
   |
 2 |     fn make() -> Self where Self: Sized;
   |                       +++++++++++++++++

trait Spawn {
    fn make() -> Self;
}

struct Cat;

impl Spawn for Cat {
    fn make() -> Self { Cat }
}

fn main() {
    let _x: Cat = Cat::make();
    println!("ok");
}

trait Greet {
    fn name(&self) -> String;

    fn hello(&self) -> String {
        format!("你好，{}", self.name())
    }
}

struct Cat;
struct Dog;

impl Greet for Cat {
    fn name(&self) -> String { String::from("猫") }
}

impl Greet for Dog {
    fn name(&self) -> String { String::from("狗") }
    fn hello(&self) -> String { String::from("汪！") }
}

fn main() {
    println!("{} / {}", Cat.hello(), Dog.hello());
}

trait Greet {
    fn name(&self) -> String;

    fn hello(&self) -> String {
        format!("你好，{}", self.name())
    }
}

struct Cat;
struct Dog;

impl Greet for Cat {}

impl Greet for Dog {
    fn name(&self) -> String { String::from("狗") }
    fn hello(&self) -> String { String::from("汪！") }
}

fn main() {
    println!("{} / {}", Cat.hello(), Dog.hello());
}

#[derive(Debug, Clone, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let a = Point { x: 1, y: 2 };
    let b = a.clone();
    println!("{:?} {} {}", a, a == b, a == Point { x: 9, y: 9 });
}

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let a = Point { x: 1, y: 2 };
    let b = a.clone();
    println!("{:?} {} {}", a, a == b, a == Point { x: 9, y: 9 });
}

use std::fmt;

impl fmt::Display for Vec<i32> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "vec({})", self.len())
    }
}

fn main() {
    println!("{}", vec![1, 2, 3]);
}

error[E0117]: only traits defined in the current crate can be implemented for types defined outside of the crate
 --> trait-orphan-rule.rs:3:1
  |
3 | impl fmt::Display for Vec<i32> {
  | ^^^^^^^^^^^^^^^^^^^^^^--------
  |                       |
  |                       `Vec` is not defined in the current crate
  |
  = note: impl doesn't have any local type before any uncovered type parameters
  = note: for more information see https://doc.rust-lang.org/reference/items/implementations.html#orphan-rules
  = note: define and implement a trait or new type instead

use std::fmt;

struct MyVec(Vec<i32>);

impl fmt::Display for MyVec {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "vec({})", self.0.len())
    }
}

fn main() {
    println!("{}", MyVec(vec![1, 2, 3]));
}