Rust 的类型系统和模式匹配

Rust 的类型系统和模式匹配是其核心特性之一，它们共同提供了强大的类型安全、代码可读性和表达能力。Rust 的类型系统比许多语言更严格，而模式匹配则允许以声明式的方式处理复杂的数据结构。

1. Rust 的类型系统

Rust 的类型系统是静态的（编译时检查）、强类型的（禁止隐式类型转换），并且支持代数数据类型（ADT）、泛型、特征（Traits）和零成本抽象。

(1) 基本类型

Rust 的基本类型包括：

• 整数：i8, i16, i32, i64, i128, u8, u16, u32, u64, u128
• 浮点数：f32, f64
• 布尔值：bool（true / false）
• 字符：char（Unicode 字符，如 'a', '🚀'）
• 复合类型：
  • 元组（Tuple）：(i32, bool, String)
  • 数组（Array）：[i32; 3]（固定长度）
  • 切片（Slice）：&[i32]（动态长度，引用部分数组）

(2) 代数数据类型（ADT）

Rust 支持两种主要的 ADT：

• 枚举（Enum）：可以包含多个变体（Variants），每个变体可以有数据。
• 结构体（Struct）：用于组合数据。

枚举（Enum）示例

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn process_message(msg: Message) {
    match msg {
        Message::Quit => println!("Quit"),
        Message::Move { x, y } => println!("Move to ({}, {})", x, y),
        Message::Write(text) => println!("Write: {}", text),
        Message::ChangeColor(r, g, b) => println!("Change color to ({}, {}, {})", r, g, b),
    }
}

特点：

• 每个变体可以有不同的数据结构。
• 编译器会检查所有变体是否被处理（避免遗漏情况）。

结构体（Struct）示例

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

fn print_point(p: Point) {
    println!("Point({}, {})", p.x, p.y);
}

(3) 泛型（Generics）

Rust 支持泛型，允许编写可重用的代码：

fn first_element<T>(arr: &[T]) -> &T {
    &arr[0]
}

fn main() {
    let nums = [1, 2, 3];
    let chars = ['a', 'b', 'c'];
    println!("{}", first_element(&nums)); // 1
    println!("{}", first_element(&chars)); // 'a'
}

特点：

• 泛型在编译时会被单态化（Monomorphization），生成特定类型的代码（零成本抽象）。
• 结合 trait 可以实现更强大的抽象。

(4) 特征（Traits）

Rust 的 trait 类似于其他语言的接口（Interface），定义了一组方法：

trait Summary {
    fn summarize(&self) -> String;
}

struct NewsArticle {
    headline: String,
    content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, {}", self.headline, self.content)
    }
}

fn print_summary(item: &impl Summary) {
    println!("{}", item.summarize());
}

特点：

• 可以用于泛型约束（T: Summary）。
• 支持默认实现（default）。
• 可以用于运算符重载（如 std::ops::Add）。

(5) 类型推断

Rust 编译器通常能推断变量类型，但也可以显式标注：

let x: i32 = 5; // 显式标注
let y = 10; // 推断为 i32

2. Rust 的模式匹配（Pattern Matching）

Rust 的模式匹配是声明式的、强大的，并且可以用于 match、if let、while let 和函数参数解构。

(1) match 表达式

match 是 Rust 最强大的模式匹配工具，可以匹配枚举、结构体、元组、切片等：

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(usize), // 25 美分硬币，带年份
}

fn value_in_cents(coin: Coin) -> u32 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(year) => {
            println!("Lucky quarter from {}", year);
            25
        },
    }
}

特点：

• 穷尽性检查：编译器会确保所有可能的情况都被处理（否则报错）。
• 绑定值：可以使用 @ 绑定变量：

  match number {
      x @ 1..=5 => println!("Small number: {}", x),
      x @ 6..=10 => println!("Medium number: {}", x),
      _ => println!("Large number"),
  }
  

(2) if let 简化匹配

如果只需要匹配一种情况，可以用 if let 避免写完整的 match：

let config_max = Some(3u8);
if let Some(max) = config_max {
    println!("Maximum is configured to be {}", max);
} else {
    println!("No maximum configured");
}

特点：

• 相当于 match 的简化版，但不检查穷尽性。
• 可以结合 else 处理其他情况。

(3) while let 循环匹配

适用于迭代动态数据（如 VecDeque）：

use std::collections::VecDeque;

let mut queue = VecDeque::new();
queue.push_back(1);
queue.push_back(2);

while let Some(x) = queue.pop_front() {
    println!("{}", x); // 1, 2
}

(4) 函数参数解构

可以直接在函数参数中解构结构体或元组：

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

fn print_coords((x, y): (i32, i32)) {
    println!("Coords: ({}, {})", x, y);
}

fn print_point(Point { x, y }: Point) {
    println!("Point: ({}, {})", x, y);
}

fn main() {
    print_coords((1, 2)); // Coords: (1, 2)
    print_point(Point { x: 3, y: 4 }); // Point: (3, 4)
}

(5) 模式匹配的常见模式

3. 类型系统 + 模式匹配 的强大组合

Rust 的类型系统和模式匹配可以安全地处理复杂数据，例如：

enum List<T> {
    Cons(T, Box<List<T>>),
    Nil,
}

fn print_list<T: std::fmt::Display>(list: &List<T>) {
    match list {
        List::Cons(head, tail) => {
            print!("{}, ", head);
            print_list(tail);
        },
        List::Nil => println!(),
    }
}

fn main() {
    let list = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));
    print_list(&list); // 1, 2,
}

分析：

• List 是一个泛型枚举，可以存储任意类型 T。
• match 安全地解构链表，编译器确保所有情况被处理。

4. 总结

Rust 的设计哲学：
“如果代码能编译通过，它大概率是正确的。”
类型系统和模式匹配共同确保了 Rust 程序的安全性和可维护性。