泛型允许编写适用于多种类型的代码，避免重复。

fn largest<T>(list: &[T]) -> &T {
    let mut largest = &list[0];
    for item in list {
        if item > largest { // 这里需要 PartialOrd 约束
            largest = item;
        }
    }
    largest
}
 
fn main() {
    let numbers = vec![34, 50, 25, 100, 65];
    println!("最大: {}", largest(&numbers));
 
    let chars = vec!['y', 'm', 'a', 'q'];
    println!("最大: {}", largest(&chars));
}

注意：以上代码需要加 PartialOrd 约束才能编译，我们稍后介绍。

struct Point<T> {
    x: T,
    y: T,
}
 
fn main() {
    let integer = Point { x: 5, y: 10 };       // Point<i32>
    let float = Point { x: 1.0, y: 4.0 };      // Point<f64>
}

struct Point<T, U> {
    x: T,
    y: U,
}
 
fn main() {
    let both = Point { x: 5, y: 4.0 }; // Point<i32, f64>
}

enum Option<T> {
    Some(T),
    None,
}
 
enum Result<T, E> {
    Ok(T),
    Err(E),
}

struct Point<T> {
    x: T,
    y: T,
}
 
impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}
 
// 专门为 f64 类型实现的方法
impl Point<f64> {
    fn distance_from_origin(&self) -> f64 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}
 
fn main() {
    let p = Point { x: 5, y: 10 };
    println!("p.x = {}", p.x());
 
    let f = Point { x: 3.0, y: 4.0 };
    println!("距离原点: {}", f.distance_from_origin());
}

Trait 定义共享行为，类似于其他语言的接口（interface）。

trait Summary {
    fn summarize(&self) -> String;
}
 
struct Article {
    title: String,
    author: String,
    content: String,
}
 
impl Summary for Article {
    fn summarize(&self) -> String {
        format!("《{}》- {}", self.title, self.author)
    }
}
 
struct Tweet {
    username: String,
    content: String,
}
 
impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("@{}: {}", self.username, self.content)
    }
}
 
fn main() {
    let article = Article {
        title: String::from("Rust 入门"),
        author: String::from("小明"),
        content: String::from("内容..."),
    };
    println!("{}", article.summarize());
 
    let tweet = Tweet {
        username: String::from("rust_fan"),
        content: String::from("学习 Rust 中！"),
    };
    println!("{}", tweet.summarize());
}

Trait 可以提供默认方法实现：

trait Summary {
    fn summarize(&self) -> String {
        String::from("（阅读更多...）")
    }
}
 
impl Summary for Article {} // 使用默认实现
 
impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("@{}: {}", self.username, self.content)
    }
}

// 方式一：impl Trait 语法
fn notify(item: impl Summary) {
    println!("通知: {}", item.summarize());
}
 
// 方式二：Trait Bound 语法
fn notify<T: Summary>(item: T) {
    println!("通知: {}", item.summarize());
}
 
// 多个参数
fn notify2(item1: impl Summary, item2: impl Summary) {}
fn notify2<T: Summary>(item1: T, item2: T) {}

use std::fmt::Display;
 
// 同时要求 impl Summary + Display
fn notify(item: impl Summary + Display) {}
 
// 或使用 where 子句
fn some<T, U>(t: T, u: U)
where
    T: Display + Clone,
    U: Clone + Summary,
{}

fn returns_summarizable() -> impl Summary {
    Article {
        title: String::from("Rust 泛型和 Trait"),
        author: String::from("老师"),
        content: String::from("内容..."),
    }
}

use std::fmt::Display;
 
trait Greet {
    fn greet(&self) -> String;
}
 
struct Person {
    name: String,
    age: u8,
}
 
impl Greet for Person {
    fn greet(&self) -> String {
        format!("你好，我叫{}，今年{}岁", self.name, self.age)
    }
}
 
fn print_greet(item: impl Greet + Display) {
    println!("{}", item.greet());
}
 
fn main() {
    let p = Person {
        name: "小明".into(),
        age: 25,
    };
    print_greet(p);
}

• 泛型允许编写类型无关的代码
• impl<T> 为泛型类型实现方法
• Trait 定义共享行为，类似接口
• impl Trait 和 T: Trait 两种约束写法
• where 子句简化复杂约束