Rust 泛型與特徵 ── 泛型函數與結構體

簡介

在 Rust 中，泛型（generics） 讓我們可以在保持安全性的前提下，寫出可重複使用且具備高抽象層次的程式碼。無論是函數、結構體、列舉或是特徵，都可以透過泛型參數抽象出「資料型別」的差異，從而避免大量重複的實作。

對於剛接觸 Rust 的開發者而言，泛型可能看起來有點抽象；但一旦掌握其核心概念，就能在日常開發中 大幅減少樣板程式碼，同時保有編譯期的型別檢查與效能。本文將以 泛型函數 與 泛型結構體 為主軸，逐步說明其語法、使用情境與常見陷阱，幫助讀者從入門走向實務應用。

---

核心概念

1. 為什麼需要泛型？

• 避免重複程式碼：相同的演算法如果針對 i32、f64、String 各寫一次，維護成本會急速上升。
• 編譯期安全：泛型在編譯時會被具體化（monomorphisation），產生與手寫專屬型別相同的效能。
• 表達意圖：使用泛型可以清楚傳達「此函數/結構體不關心具體型別，只要滿足某些條件即可」的設計意圖。

2. 基本語法：泛型參數的宣告

在 Rust 中，泛型參數放在方括號 [] 內，通常以單一大寫字母命名（如 T、U）。以下是一個最簡單的範例：

fn identity<T>(value: T) -> T {
    // 直接回傳傳入的值
    value
}

• T 是 類型參數，在呼叫 identity 時會被具體型別取代。
• 函數本身不需要知道 T 的具體內容，只要能接受與回傳相同型別即可。

3. 泛型函數的實務範例

3.1 多型的加法函數

use std::ops::Add;

/// 只要型別支援 `Add`（加法）與 `Copy`（可複製），就能使用此函數
fn add<T>(a: T, b: T) -> T
where
    T: Add<Output = T> + Copy,
{
    a + b
}

fn main() {
    let int_sum = add(3, 5);               // i32
    let float_sum = add(2.5, 4.1);         // f64
    println!("int: {}, float: {}", int_sum, float_sum);
}

• where 子句限定 T 必須實作 Add（回傳同型別）與 Copy，確保可以直接使用 + 運算子。
• 好處：同一個函數同時支援整數與浮點數，且編譯器會在每次呼叫時生成對應的專屬實作。

3.2 取得容器中最小值

use std::cmp::PartialOrd;

/// 回傳 slice 中的最小元素
fn min<T>(slice: &[T]) -> Option<&T>
where
    T: PartialOrd,
{
    slice.iter().min_by(|a, b| a.partial_cmp(b).unwrap())
}

fn main() {
    let numbers = [4, 2, 8, 1];
    let words = ["apple", "banana", "cherry"];
    println!("min number: {:?}", min(&numbers));
    println!("min word: {:?}", min(&words));
}

• PartialOrd 允許比較大小（不一定全序，例如 NaN）。
• 回傳 Option<&T>，避免空 slice 時 panic，展現 安全設計。

3.3 產生任意型別的預設值

/// 只要型別實作 `Default`，就能產生預設值
fn default_value<T>() -> T
where
    T: Default,
{
    T::default()
}

fn main() {
    let zero: i32 = default_value();          // 0
    let empty: String = default_value();      // ""
    println!("zero = {}, empty = \"{}\"", zero, empty);
}

• Default 為標準特徵，提供「零值」或「空值」的建構方式。
• 此函數不需要任何參數，即可根據呼叫端的型別返回對應的預設值。

4. 泛型結構體

4.1 基本範例：Point<T>

#[derive(Debug, Clone, Copy)]
struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    /// 建立新座標點
    fn new(x: T, y: T) -> Self {
        Self { x, y }
    }
}

fn main() {
    let p1 = Point::new(3, 4);           // i32
    let p2 = Point::new(1.5, 2.5);       // f64
    println!("{:?}", p1);
    println!("{:?}", p2);
}

• Point<T> 的兩個欄位必須是相同型別 T。
• impl<T> 為 泛型實作區塊，讓所有 T 都共享相同的方法。

4.2 多型的 Pair<T, U>

#[derive(Debug)]
struct Pair<T, U> {
    first: T,
    second: U,
}

impl<T, U> Pair<T, U> {
    fn swap(self) -> Pair<U, T> {
        Pair {
            first: self.second,
            second: self.first,
        }
    }
}

fn main() {
    let pair = Pair { first: "hello", second: 42 };
    let swapped = pair.swap();   // Pair<i32, &str>
    println!("{:?}", swapped);
}

• 兩個不同的泛型參數 T、U 讓結構體可以同時保存不同型別的資料。
• swap 方法示範 型別變換：回傳的 Pair<U, T> 位置互換。

4.3 使用特徵界限（Trait Bounds）於結構體

use std::ops::Add;

/// 只要 `T` 支援 `Add`，就能計算兩個值的總和
#[derive(Debug)]
struct Sum<T> {
    a: T,
    b: T,
}

impl<T> Sum<T>
where
    T: Add<Output = T> + Copy,
{
    fn total(&self) -> T {
        self.a + self.b
    }
}

fn main() {
    let int_sum = Sum { a: 10, b: 20 };
    let float_sum = Sum { a: 1.5, b: 2.5 };
    println!("int total = {}", int_sum.total());
    println!("float total = {}", float_sum.total());
}

• where 子句限制 T 必須實作 Add 且回傳同型別，並且能 Copy。
• 這樣的 特徵界限 讓結構體的行為在不同型別間保持一致。

5. 泛型與特徵的結合

在 Rust 中，特徵（trait） 本身也可以是泛型的，稱為「特徵參數化」或「關聯型別」。以下示範一個簡單的 Container 特徵：

trait Container {
    type Item;

    fn push(&mut self, item: Self::Item);
    fn pop(&mut self) -> Option<Self::Item>;
}

impl<T> Container for Vec<T> {
    type Item = T;

    fn push(&mut self, item: T) {
        self.push(item);
    }

    fn pop(&mut self) -> Option<T> {
        self.pop()
    }
}

• type Item; 為 關聯型別，讓實作者自行決定容器內部儲存的型別。
• Vec<T> 的實作證明 泛型結構體 完全可以配合 特徵 使用，形成高度抽象的介面。

---

常見陷阱與最佳實踐

陷阱	說明	解決方案
過度使用 where T: Clone	若不真的需要 Clone，會導致不必要的拷貝成本。	僅在需要複製時才加入 Clone，或改用 &T 參考。
忘記 Copy 限制	在使用 +、* 等運算子時，若型別未實作 Copy，會出現所有權錯誤。	加上 T: Copy 或改為 &T 參考傳遞。
特徵界限寫在 impl 上而非函式	會導致所有方法都被限制，即使只有部分方法需要該特徵。	使用 方法級別的 where，只限制需要的函式。
過度抽象導致編譯時間激增	泛型具體化會產生大量程式碼，編譯時間會變長。	在確定效能需求前，適度使用具體型別；或利用 #[inline] 控制內聯。
使用 dyn Trait 時忘記生命週期	動態特徵物件需要明確的生命週期標註，否則會編譯錯誤。	為 Box<dyn Trait> 加上 'static 或適當的 'a 生命週期。

最佳實踐

1. 先寫具體型別，再抽象成泛型：先確保演算法正確，再逐步提升抽象層次。
2. 盡量使用 where 子句，讓函式簽名保持簡潔。
3. 利用 #[derive] 為泛型結構體自動實作 Debug、Clone、PartialEq 等常用特徵，減少樣板。
4. 測試每個具體化的型別：即使編譯器保證安全，仍建議在單元測試中覆蓋不同型別的使用情境。

---

實際應用場景

場景	為何使用泛型	範例
資料結構庫（如 LinkedList<T>、BinaryTree<T>）	同一套演算法可支援任意資料型別	struct Node<T> { value: T, next: Option<Box<Node<T>>> }
序列化/反序列化框架（serde）	需要將任意型別轉換成 JSON、二進位等格式	fn serialize<T: Serialize>(value: &T) -> String
演算法函式庫（排序、搜尋）	只要提供比較特徵，即可對多種型別排序	fn quicksort<T: Ord>(arr: &mut [T])
依賴注入與抽象介面	透過特徵與泛型，讓不同實作可互換	fn run_service<S: Service>(svc: S)
遊戲開發中的向量與矩陣	同一套向量運算可支援 f32、f64、i32 等	struct Vec2<T> { x: T, y: T }

---

總結

• 泛型 是 Rust 提供的強大工具，讓我們能以最小的樣板程式碼支援多種資料型別，同時保有編譯期的安全與零成本抽象。
• 泛型函數 透過 where 子句與特徵界限（trait bounds）限制型別行為，確保只有符合條件的型別才能使用。
• 泛型結構體 能夠保存任意型別的資料，結合特徵界限後更能提供具體的行為（如加法、比較）。
• 特徵與關聯型別 的結合，使得抽象介面與具體實作之間的橋樑更加靈活。
• 在實務開發中，合理使用泛型可提升程式碼的可讀性、可維護性與效能；但也要注意過度抽象可能帶來的編譯時間與可讀性問題。

掌握了 泛型函數與結構體，你就能在 Rust 生態系中寫出更具彈性、可重用且安全的程式碼，為未來的專案奠定堅實的基礎。祝你在 Rust 的旅程中玩得開心，寫出優雅的程式！