Traits and Generics §§ZH§§ Trait 与泛型 - Rust for C# Programmers

Traits - Rust’s Interfaces
Trait：Rust 里的接口机制

What you’ll learn: Traits compared with C# interfaces, default method implementations, trait objects (dyn Trait) versus generic bounds (impl Trait), derived traits, common standard-library traits, associated types, and operator overloading through traits.
本章将学到什么： 对照理解 Trait 和 C# 接口的关系，掌握默认方法实现、trait object dyn Trait 与泛型约束 impl Trait 的区别，理解自动派生 trait、常见标准库 trait、关联类型，以及如何通过 trait 实现运算符重载。

Difficulty: 🟡 Intermediate
难度： 🟡 进阶

Traits are Rust’s mechanism for describing shared behavior. They play a role similar to interfaces in C#, but they also stretch into areas that C# interfaces do not cover, such as operator overloading and associated types.
Trait 是 Rust 用来描述“共享行为”的核心机制。它和 C# 的接口确实有相似之处，但它能覆盖的范围更大，像运算符重载、关联类型这些能力，都直接建在 trait 体系上。

C# Interface Comparison
先和 C# 接口对照一下

// C# interface definition
public interface IAnimal
{
    string Name { get; }
    void MakeSound();
    
    // Default implementation (C# 8+)
    string Describe()
    {
        return $"{Name} makes a sound";
    }
}

// C# interface implementation
public class Dog : IAnimal
{
    public string Name { get; }
    
    public Dog(string name)
    {
        Name = name;
    }
    
    public void MakeSound()
    {
        Console.WriteLine("Woof!");
    }
    
    // Can override default implementation
    public string Describe()
    {
        return $"{Name} is a loyal dog";
    }
}

// Generic constraints
public void ProcessAnimal<T>(T animal) where T : IAnimal
{
    animal.MakeSound();
    Console.WriteLine(animal.Describe());
}

Rust Trait Definition and Implementation
Rust Trait 的定义与实现

// Trait definition
trait Animal {
    fn name(&self) -> &str;
    fn make_sound(&self);
    
    // Default implementation
    fn describe(&self) -> String {
        format!("{} makes a sound", self.name())
    }
    
    // Default implementation using other trait methods
    fn introduce(&self) {
        println!("Hi, I'm {}", self.name());
        self.make_sound();
    }
}

// Struct definition
#[derive(Debug)]
struct Dog {
    name: String,
    breed: String,
}

impl Dog {
    fn new(name: String, breed: String) -> Dog {
        Dog { name, breed }
    }
}

// Trait implementation
impl Animal for Dog {
    fn name(&self) -> &str {
        &self.name
    }
    
    fn make_sound(&self) {
        println!("Woof!");
    }
    
    // Override default implementation
    fn describe(&self) -> String {
        format!("{} is a loyal {} dog", self.name, self.breed)
    }
}

// Another implementation
#[derive(Debug)]
struct Cat {
    name: String,
    indoor: bool,
}

impl Animal for Cat {
    fn name(&self) -> &str {
        &self.name
    }
    
    fn make_sound(&self) {
        println!("Meow!");
    }
    
    // Use default describe() implementation
}

// Generic function with trait bounds
fn process_animal<T: Animal>(animal: &T) {
    animal.make_sound();
    println!("{}", animal.describe());
    animal.introduce();
}

// Multiple trait bounds
fn process_animal_debug<T: Animal + std::fmt::Debug>(animal: &T) {
    println!("Debug: {:?}", animal);
    process_animal(animal);
}

fn main() {
    let dog = Dog::new("Buddy".to_string(), "Golden Retriever".to_string());
    let cat = Cat { name: "Whiskers".to_string(), indoor: true };
    
    process_animal(&dog);
    process_animal(&cat);
    
    process_animal_debug(&dog);
}

看到这里，可以先把 Trait 暂时理解成“接口加一堆额外超能力”。
默认方法、基于 trait 的泛型约束、和其他 trait 组合使用，这些在 C# 里也有影子，但 Rust 把它们揉得更紧、更统一。

Trait Objects and Dynamic Dispatch
Trait Object 与动态分发

// C# dynamic polymorphism
public void ProcessAnimals(List<IAnimal> animals)
{
    foreach (var animal in animals)
    {
        animal.MakeSound(); // Dynamic dispatch
        Console.WriteLine(animal.Describe());
    }
}

// Usage
var animals = new List<IAnimal>
{
    new Dog("Buddy"),
    new Cat("Whiskers"),
    new Dog("Rex")
};

ProcessAnimals(animals);

// Rust trait objects for dynamic dispatch
fn process_animals(animals: &[Box<dyn Animal>]) {
    for animal in animals {
        animal.make_sound(); // Dynamic dispatch
        println!("{}", animal.describe());
    }
}

// Alternative: using references
fn process_animal_refs(animals: &[&dyn Animal]) {
    for animal in animals {
        animal.make_sound();
        println!("{}", animal.describe());
    }
}

fn main() {
    // Using Box<dyn Trait>
    let animals: Vec<Box<dyn Animal>> = vec![
        Box::new(Dog::new("Buddy".to_string(), "Golden Retriever".to_string())),
        Box::new(Cat { name: "Whiskers".to_string(), indoor: true }),
        Box::new(Dog::new("Rex".to_string(), "German Shepherd".to_string())),
    ];
    
    process_animals(&animals);
    
    // Using references
    let dog = Dog::new("Buddy".to_string(), "Golden Retriever".to_string());
    let cat = Cat { name: "Whiskers".to_string(), indoor: true };
    
    let animal_refs: Vec<&dyn Animal> = vec![&dog, &cat];
    process_animal_refs(&animal_refs);
}

这里就开始出现 Rust 独有的取舍题了：到底要静态分发，还是动态分发。
C# 开发者经常习惯“接口一套上，先跑起来再说”；Rust 则会逼着在抽象能力、分配成本、调用方式之间先做决定，这一点后面会越来越频繁出现。

Derived Traits
派生 Trait

// Automatically derive common traits
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
struct Person {
    name: String,
    age: u32,
}

// What this generates (simplified):
impl std::fmt::Debug for Person {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Person")
            .field("name", &self.name)
            .field("age", &self.age)
            .finish()
    }
}

impl Clone for Person {
    fn clone(&self) -> Self {
        Person {
            name: self.name.clone(),
            age: self.age,
        }
    }
}

impl PartialEq for Person {
    fn eq(&self, other: &Self) -> bool {
        self.name == other.name && self.age == other.age
    }
}

// Usage
fn main() {
    let person1 = Person {
        name: "Alice".to_string(),
        age: 30,
    };
    
    let person2 = person1.clone(); // Clone trait
    
    println!("{:?}", person1); // Debug trait
    println!("Equal: {}", person1 == person2); // PartialEq trait
}

derive 是 Rust 里非常香的一块。
很多通用能力比如调试打印、克隆、比较、哈希，结构体字段本身已经足够表达语义时，就没必要手写一大堆模板实现，直接 #[derive(...)] 最省力。

Common Standard Library Traits
常见标准库 Trait

use std::collections::HashMap;

// Display trait for user-friendly output
impl std::fmt::Display for Person {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{} (age {})", self.name, self.age)
    }
}

// From trait for conversions
impl From<(String, u32)> for Person {
    fn from((name, age): (String, u32)) -> Self {
        Person { name, age }
    }
}

// Into trait is automatically implemented when From is implemented
fn create_person() {
    let person: Person = ("Alice".to_string(), 30).into();
    println!("{}", person);
}

// Iterator trait implementation
struct PersonIterator {
    people: Vec<Person>,
    index: usize,
}

impl Iterator for PersonIterator {
    type Item = Person;
    
    fn next(&mut self) -> Option<Self::Item> {
        if self.index < self.people.len() {
            let person = self.people[self.index].clone();
            self.index += 1;
            Some(person)
        } else {
            None
        }
    }
}

impl Person {
    fn iterator(people: Vec<Person>) -> PersonIterator {
        PersonIterator { people, index: 0 }
    }
}

fn main() {
    let people = vec![
        Person::from(("Alice".to_string(), 30)),
        Person::from(("Bob".to_string(), 25)),
        Person::from(("Charlie".to_string(), 35)),
    ];
    
    // Use our custom iterator
    for person in Person::iterator(people.clone()) {
        println!("{}", person); // Uses Display trait
    }
}

这部分很值得建立“trait 是生态接线口”的感觉。
只要实现了对应 trait，类型就能自动接入标准库和常见惯用法。例如实现 Display 就能优雅打印，实现 From 就能进转换链，实现 Iterator 就能进 for 循环和迭代器生态。

🏋️ Exercise: Trait-Based Drawing System
🏋️ 练习：基于 Trait 的绘图系统

Challenge: Implement a Drawable trait with an area() method and a default draw() method. Create Circle and Rect structs, then write a function that accepts &[Box<dyn Drawable>] and prints the total area.
挑战： 实现一个 Drawable trait，包含 area() 方法和默认的 draw() 方法；再创建 Circle 和 Rect 两个结构体，最后写一个能接收 &[Box<dyn Drawable>] 并打印总面积的函数。

🔑 Solution
🔑 参考答案

use std::f64::consts::PI;

trait Drawable {
    fn area(&self) -> f64;

    fn draw(&self) {
        println!("Drawing shape with area {:.2}", self.area());
    }
}

struct Circle { radius: f64 }
struct Rect   { w: f64, h: f64 }

impl Drawable for Circle {
    fn area(&self) -> f64 { PI * self.radius * self.radius }
}

impl Drawable for Rect {
    fn area(&self) -> f64 { self.w * self.h }
}

fn total_area(shapes: &[Box<dyn Drawable>]) -> f64 {
    shapes.iter().map(|s| s.area()).sum()
}

fn main() {
    let shapes: Vec<Box<dyn Drawable>> = vec![
        Box::new(Circle { radius: 5.0 }),
        Box::new(Rect { w: 4.0, h: 6.0 }),
        Box::new(Circle { radius: 2.0 }),
    ];
    for s in &shapes { s.draw(); }
    println!("Total area: {:.2}", total_area(&shapes));
}

Key takeaways:
这一题最该记住的点：

dyn Trait gives runtime polymorphism similar to using an interface in C#.
dyn Trait 提供的是运行时多态，味道上很像 C# 里的接口多态。
Box<dyn Trait> is heap-allocated and is often needed for heterogeneous collections.
Box<dyn Trait> 往往意味着堆分配，异构集合里经常少不了它。
Default trait methods behave very much like C# 8+ default interface methods.
Trait 默认方法的感觉，和 C# 8 之后的默认接口实现很接近。

Associated Types: Traits With Type Members
关联类型：Trait 里的类型成员

C# interfaces do not have a direct associated-type concept, but Rust traits do. The classic example is Iterator.
C# 接口里没有和“关联类型”完全对等的原生概念，而 Rust trait 有。最经典的例子就是 Iterator。

#![allow(unused)]
fn main() {
// The Iterator trait has an associated type 'Item'
trait Iterator {
    type Item;                         // Each implementor defines what Item is
    fn next(&mut self) -> Option<Self::Item>;
}

struct Counter { max: u32, current: u32 }

impl Iterator for Counter {
    type Item = u32;                   // This Counter yields u32 values
    fn next(&mut self) -> Option<u32> {
        if self.current < self.max {
            self.current += 1;
            Some(self.current)
        } else {
            None
        }
    }
}
}

In C#, IEnumerator<T> or IEnumerable<T> use generic parameters for this role. Rust’s associated types tie the type member to the implementation itself, which often makes trait bounds easier to read.
在 C# 里，IEnumerator<T>、IEnumerable<T> 主要靠泛型参数解决这个问题；Rust 的关联类型则把“这个实现到底产出什么类型”直接绑定在实现上。这样一来，很多约束写出来会更短、更清楚。

Operator Overloading via Traits
通过 Trait 做运算符重载

In C#, operator overloading is done by defining static operator methods. In Rust, every operator maps to a trait in std::ops.
C# 里写运算符重载，通常是定义静态 operator 方法；Rust 则是把每个运算符都映射成 std::ops 里的某个 trait。

#![allow(unused)]
fn main() {
use std::ops::Add;

#[derive(Debug, Clone, Copy)]
struct Vec2 { x: f64, y: f64 }

impl Add for Vec2 {
    type Output = Vec2;
    fn add(self, rhs: Vec2) -> Vec2 {
        Vec2 { x: self.x + rhs.x, y: self.y + rhs.y }
    }
}

let a = Vec2 { x: 1.0, y: 2.0 };
let b = Vec2 { x: 3.0, y: 4.0 };
let c = a + b;  // calls <Vec2 as Add>::add(a, b)
}

C#	Rust	Notes 说明
`operator+` 加号重载	`impl Add` 实现 `Add`	`self` by value; may consume non-`Copy` types 按值接收 `self`，非 `Copy` 类型可能被消费
`operator==` 相等比较	`impl PartialEq` 实现 `PartialEq`	Often derived 通常可以直接 derive
`operator<` 大小比较	`impl PartialOrd` 实现 `PartialOrd`	Often derived 通常也能 derive
`ToString()` `ToString()`	`impl fmt::Display` 实现 `fmt::Display`	Used by `println!("{}", x)` 供 `println!("{}", x)` 使用
Implicit conversion 隐式转换	No direct equivalent 没有直接等价物	Prefer `From` / `Into` 通常用 `From` / `Into`

这部分再次说明了一件事：Trait 在 Rust 里不只是“面向对象接口”，它还是语言运算规则的挂载点。
一旦理解这一层，很多看起来分散的能力，比如格式化、比较、加法、迭代、转换，就会突然串起来。

Coherence: The Orphan Rule
一致性规则：孤儿规则

You can only implement a trait if the current crate owns either the trait or the type. This prevents conflicting implementations across crates.
Rust 规定：只有在当前 crate 拥有这个 trait，或者拥有这个类型时，才能写对应实现。这个限制就是常说的孤儿规则，它的目标是避免不同 crate 之间出现互相冲突的实现。

#![allow(unused)]
fn main() {
// ✅ OK — you own MyType
impl Display for MyType { ... }

// ✅ OK — you own MyTrait
impl MyTrait for String { ... }

// ❌ ERROR — you own neither Display nor String
impl Display for String { ... }
}

C# 没有这一层限制，所以扩展方法可以随便往外加。
Rust 则更保守一些，宁可先把实现边界卡严，也不想让生态里不同库对同一个组合各写一套实现，然后把调用方整懵。

`impl Trait`: Returning Traits Without Boxing
`impl Trait`：不装箱也能返回 Trait

C# interfaces can always be used as return types, and the runtime takes care of dispatch and allocation. Rust makes the decision explicit: static dispatch with impl Trait, or dynamic dispatch with dyn Trait.
C# 里接口当返回类型是常规操作，运行时会把后续分发和对象布局兜住；Rust 则要求把这件事说清楚，到底是 impl Trait 的静态分发，还是 dyn Trait 的动态分发。

`impl Trait` in Argument Position (Shorthand for Generics)
参数位置上的 `impl Trait`（泛型语法糖）

#![allow(unused)]
fn main() {
// These two are equivalent:
fn print_animal(animal: &impl Animal) { animal.make_sound(); }
fn print_animal<T: Animal>(animal: &T)  { animal.make_sound(); }

// impl Trait is just syntactic sugar for a generic parameter
// The compiler generates a specialized copy for each concrete type (monomorphization)
}

这里的 impl Trait 主要是让签名更短、更顺眼。
本质上还是泛型，编译器照样会做单态化，不是什么新的运行时机制。

`impl Trait` in Return Position (The Key Difference)
返回位置上的 `impl Trait`（这里才是重点）

// Return an iterator without exposing the concrete type
fn even_squares(limit: u32) -> impl Iterator<Item = u32> {
    (0..limit)
        .filter(|n| n % 2 == 0)
        .map(|n| n * n)
}
// The caller sees "some type that implements Iterator<Item = u32>"
// The actual type (Filter<Map<Range<u32>, ...>>) is unnameable — impl Trait solves this.

fn main() {
    for n in even_squares(20) {
        print!("{n} ");
    }
    // Output: 0 4 16 36 64 100 144 196 256 324
}

// C# — returning an interface (always dynamic dispatch, heap-allocated iterator object)
public IEnumerable<int> EvenSquares(int limit) =>
    Enumerable.Range(0, limit)
        .Where(n => n % 2 == 0)
        .Select(n => n * n);
// The return type hides the concrete iterator behind the IEnumerable interface
// Unlike Rust's Box<dyn Trait>, C# doesn't explicitly box — the runtime handles allocation

这一块是很多 C# 开发者第一次真正意识到 Rust 抽象成本不是“系统替你决定”的时刻。
返回 impl Trait 意味着：类型虽然藏起来了，但编译器仍然知道它的具体身份，所以还能继续做静态优化。

Returning Closures: `impl Fn` vs `Box<dyn Fn>`
返回闭包：`impl Fn` 与 `Box<dyn Fn>`

#![allow(unused)]
fn main() {
// Return a closure — you CANNOT name the closure type, so impl Fn is essential
fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
    move |y| x + y
}

let add5 = make_adder(5);
println!("{}", add5(3)); // 8

// If you need to return DIFFERENT closures conditionally, you need Box:
fn choose_op(add: bool) -> Box<dyn Fn(i32, i32) -> i32> {
    if add {
        Box::new(|a, b| a + b)
    } else {
        Box::new(|a, b| a * b)
    }
}
// impl Trait requires a SINGLE concrete type; different closures are different types
}

// C# — delegates handle this naturally (always heap-allocated)
Func<int, int> MakeAdder(int x) => y => x + y;
Func<int, int, int> ChooseOp(bool add) => add ? (a, b) => a + b : (a, b) => a * b;

这里最该记住的一句就是：impl Trait 只能代表一个具体类型。
如果分支里返回的是两个不同闭包，那它们在 Rust 看来就是两个完全不同的匿名类型，这时就得退回 Box<dyn Fn> 这种动态分发方案。

The Dispatch Decision: `impl Trait` vs `dyn Trait` vs Generics
分发选择：`impl Trait`、`dyn Trait` 还是泛型

This choice becomes an architectural question very quickly in Rust. The following diagram gives the rough mental map.
这件事在 Rust 里很快就会上升成架构选择题。下面这张图就是一份大致的脑图。

graph TD
    START["Function accepts or returns<br/>a trait-based type?<br/>函数参数或返回值涉及 Trait？"]
    POSITION["Argument or return position?<br/>是在参数位置还是返回位置？"]
    ARG_SAME["All callers pass<br/>the same type?<br/>调用者传入的具体类型是否固定？"]
    RET_SINGLE["Always returns the<br/>same concrete type?<br/>是否始终返回同一个具体类型？"]
    COLLECTION["Storing in a collection<br/>or as struct field?<br/>要不要放进集合或结构体字段？"]

    GENERIC["Use generics<br/><code>fn foo&lt;T: Trait&gt;(x: T)</code>"]
    IMPL_ARG["Use impl Trait<br/><code>fn foo(x: impl Trait)</code>"]
    IMPL_RET["Use impl Trait<br/><code>fn foo() -> impl Trait</code>"]
    DYN_BOX["Use Box&lt;dyn Trait&gt;<br/>Dynamic dispatch"]
    DYN_REF["Use &dyn Trait<br/>Borrowed dynamic dispatch"]

    START --> POSITION
    POSITION -->|Argument| ARG_SAME
    POSITION -->|Return| RET_SINGLE
    ARG_SAME -->|"Yes (syntactic sugar)"| IMPL_ARG
    ARG_SAME -->|"Complex bounds/multiple uses"| GENERIC
    RET_SINGLE -->|Yes| IMPL_RET
    RET_SINGLE -->|"No (conditional types)"| DYN_BOX
    RET_SINGLE -->|"Heterogeneous collection"| COLLECTION
    COLLECTION -->|Owned| DYN_BOX
    COLLECTION -->|Borrowed| DYN_REF

    style GENERIC fill:#c8e6c9,color:#000
    style IMPL_ARG fill:#c8e6c9,color:#000
    style IMPL_RET fill:#c8e6c9,color:#000
    style DYN_BOX fill:#fff3e0,color:#000
    style DYN_REF fill:#fff3e0,color:#000

Approach 方案	Dispatch 分发方式	Allocation 分配	When to Use 适用场景
`fn foo<T: Trait>(x: T)` 泛型约束	Static 静态分发	Stack 通常不额外堆分配	Same type reused, complex bounds 同一类型多次复用，或约束比较复杂时
`fn foo(x: impl Trait)` 参数位置 `impl Trait`	Static 静态分发	Stack 通常不额外堆分配	Cleaner syntax for simple bounds 语法更简洁，适合简单约束
`fn foo() -> impl Trait` 返回位置 `impl Trait`	Static 静态分发	Stack 通常不额外堆分配	Single concrete return type 始终返回同一个具体类型时
`fn foo() -> Box<dyn Trait>` 装箱动态分发	Dynamic 动态分发	Heap 堆分配	Different return types, heterogeneous collections 返回类型不止一种，或需要异构集合
`&dyn Trait` / `&mut dyn Trait` 借用的 trait object	Dynamic 动态分发	No alloc 不额外分配	Borrowed heterogeneous values 只借用异构值时

#![allow(unused)]
fn main() {
// Summary: from fastest to most flexible
fn static_dispatch(x: impl Display)             { /* fastest, no alloc */ }
fn generic_dispatch<T: Display + Clone>(x: T)    { /* fastest, multiple bounds */ }
fn dynamic_dispatch(x: &dyn Display)             { /* vtable lookup, no alloc */ }
fn boxed_dispatch(x: Box<dyn Display>)           { /* vtable lookup + heap alloc */ }
}

可以把这整段话压缩成一句土话：先默认静态分发，真有必要再上 dyn Trait。
也就是说，优先考虑泛型和 impl Trait；只有在确实需要异构集合、条件分支返回不同实现，或者必须持有 trait object 时，再接受动态分发和装箱成本。

Keyboard shortcuts

Rust for C# Programmers | Rust 面向 C# 程序员