1.摘要

Rust中的泛型可以讓我們為像函數簽名或結構體這樣的項創建定義, 這樣它們就可以用于多種不同的具體數據類型。下面的內容將涉及泛型定義函數、結構體、枚舉和方法, 還將討論泛型如何影響代碼性能。

2.在函數定義中使用泛型

當使用泛型定義函數時，本來在函數簽名中指定參數和返回值的類型的地方，會改用泛型來表示。采用這種技術，使得代碼適應性更強，從而為函數的調用者提供更多的功能，同時也避免了代碼的重復。

看下面的代碼例子, 定義了兩個函數, 功能都差不多,作用是分別尋找slice中最大的i32和slice中最大的char, 只是數據類型不同。

fn largest_i32(list: &[i32]) -> &i32 {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn largest_char(list: &[char]) -> &char {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest_i32(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest_char(&char_list);
    println!("The largest char is {}", result);
}

編譯一下代碼, 輸出如下:

我們現在需要定義一個新函數, 引進泛型參數來消除這種因數據類型不同而導致的函數重復定義。為了參數化這個新函數中的這些類型，我們需要為類型參數命名，道理和給函數的形參起名一樣。任何標識符都可以作為類型參數的名字。這里選用 T，因為傳統上來說，Rust 的類型參數名字都比較短，通常僅為一個字母，同時，Rust 類型名的命名規范是首字母大寫駝峰式命名法（UpperCamelCase）。T 作為 “type” 的縮寫是大部分 Rust 程序員的首選。

如果要在函數體中使用參數，就必須在函數簽名中聲明它的名字，好讓編譯器知道這個名字指代的是什么。同理，當在函數簽名中使用一個類型參數時，必須在使用它之前就聲明它。為了定義泛型版本的 largest 函數，類型參數聲明位于函數名稱與參數列表中間的尖括號 <> 中，像這樣：

fn largest<T>(list: &[T]) -> &T

可以這樣理解這個定義：函數 largest 有泛型類型 T。它有個參數 list，其類型是元素為 T 的 slice。largest 函數會返回一個與 T 相同類型的引用。

按照這個思想, 我們將代碼改造如下:

fn largest<T>(list: &[T]) -> &T {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {}", result);
}

一切似乎很順利, 嘗試編譯這段代碼, 編譯器結果如下:

這次編譯沒有通過的原因Rust編譯器用綠色標識出來了, 缺少一個: std:cmp::PartialOrd, 先暫且認為這個是Rust標準庫要求的東西, 加上重新編譯一下試試:

fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

重新編譯結果如下:

我們在代碼中下了一個斷點, 能夠執行到此處說明代碼已經沒有問題。實際上上面這個錯誤表明 largest 的函數體不能適用于 T 的所有可能的類型。因為在函數體需要比較 T 類型的值，不過它只能用于我們知道如何排序的類型。為了開啟比較功能，標準庫中定義的 std::cmp::PartialOrd trait 可以實現類型的比較功能, 我們限制 T 只對實現了 PartialOrd 的類型有效后代碼就可以編譯了，因為標準庫為 i32 和 char 實現了 PartialOrd。

3.在結構體中使用泛型

同樣也可以用 <> 語法來定義結構體，它包含一個或多個泛型參數類型字段。下面的代碼片段定義了一個可以存放任何類型的 x 和 y 坐標值的結構體 Point：

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };
}

其語法類似于函數定義中使用泛型。首先，必須在結構體名稱后面的尖括號中聲明泛型參數的名稱。接著在結構體定義中可以指定具體數據類型的位置使用泛型類型。

注意 Point<T> 的定義中只使用了一個泛型類型，這個定義表明結構體 Point<T> 對于一些類型 T 是泛型的，而且字段 x 和 y 都是 相同類型的，無論它具體是何類型。

如果嘗試創建一個有不同類型值的 Point<T> 的實例, 看下面的代碼:

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let wont_work = Point { x: 5, y: 4.0 };
}

在這個例子中，當把整型值 5 賦值給 x 時，就告訴了編譯器這個 Point<T> 實例中的泛型 T 全是整型。接著指定 y 為浮點值 4.0，因為它y被定義為與 x 相同類型，所以將會得到一個像這樣的類型不匹配錯誤：

如果想要定義一個 x 和 y 可以有不同類型且仍然是泛型的 Point 結構體，我們可以使用多個泛型類型參數。修改 Point 的定義為擁有兩個泛型類型 T 和 U。其中字段 x 是 T 類型的，而字段 y 是 U 類型的：

struct Point<T, U> {
    x: T,
    y: U,
}

fn main() {
    let both_integer = Point { x: 5, y: 10 };
    let both_float = Point { x: 1.0, y: 4.0 };
    let integer_and_float = Point { x: 5, y: 4.0 };
}

現在所有這些 Point 實例都合法了！我們可以在定義中使用任意多的泛型類型參數，不過太多的話，代碼將難以閱讀和理解。當你發現代碼中需要很多泛型時，這可能表明你的代碼需要重構分解成更小的結構。

4.枚舉中使用泛型

和結構體類似，枚舉也可以在成員中存放泛型數據類型。例如:

enum Option<T> {
    Some(T),
    None,
}

Option<T> 是一個擁有泛型 T 的枚舉，它有兩個成員：Some，它存放了一個類型 T 的值，和不存在任何值的None。通過 Option<T> 枚舉可以表達有一個可能的值的抽象概念，同時因為 Option<T> 是泛型的，無論這個可能的值是什么類型都可以使用這個抽象。

枚舉也可以擁有多個泛型類型, 例如:

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

Result 枚舉有兩個泛型類型，T 和 E。Result 有兩個成員：Ok，它存放一個類型 T 的值，而 Err 則存放一個類型 E 的值。這個定義使得 Result 枚舉能很方便的表達任何可能成功（返回 T 類型的值）也可能失敗（返回 E 類型的值）的操作。

總結:當意識到代碼中定義了多個結構體或枚舉，它們不一樣的地方只是其中的值的類型的時候，不妨通過泛型類型來避免重復。

5.方法定義中的泛型

在為結構體和枚舉實現方法時, 一樣也可以用泛型。看下面的代碼:

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

這里在 Point<T> 上定義了一個叫做 x 的方法來返回字段 x 中數據的引用。注意必須在 impl 后面聲明 T，這樣就可以在 Point<T> 上實現的方法中使用 T 了。通過在 impl 之后聲明泛型 T，Rust 就知道 Point 的尖括號中的類型是泛型而不是具體類型。我們可以為泛型參數選擇一個與結構體定義中聲明的泛型參數所不同的名稱，不過依照慣例使用了相同的名稱。impl 中編寫的方法聲明了泛型類型可以定位為任何類型的實例，不管最終替換泛型類型的是何具體類型。

定義方法時也可以為泛型指定限制（constraint）。例如，可以選擇為 Point<f32> 實例實現方法，而不是為泛型 Point 實例。代碼如下:

impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

這段代碼意味著 Point<f32> 類型會有一個方法 distance_from_origin，而其他 T 不是 f32 類型的 Point<T> 實例則沒有定義此方法。這個方法計算點實例與坐標 (0.0, 0.0) 之間的距離，并使用了只能用于浮點型的數學運算符。

結構體定義中的泛型類型參數并不總是與結構體方法簽名中使用的泛型是同一類型。看下面的代碼:

struct Point<X1, Y1> {
    x: X1,
    y: Y1,
}

impl<X1, Y1> Point<X1, Y1> {
    fn mixup<X2, Y2>(self, other: Point<X2, Y2>) -> Point<X1, Y2> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

fn main() {
    let p1 = Point { x: 5, y: 10.4 };
    let p2 = Point { x: "Hello", y: 'c' };

    let p3 = p1.mixup(p2);

    println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
}

在上面的代碼中, Point 結構體使用了泛型類型 X1 和 Y1，為 mixup 方法簽名使用了 X2 和 Y2 來使得示例更加清楚。這個方法用 self 的 Point 類型的 x 值（類型 X1）和參數的 Point 類型的 y 值（類型 Y2）來創建一個新 Point 類型的實例

在 main 函數中，定義了一個有 i32 類型的 x（其值為 5）和 f64 的 y（其值為 10.4）的 Point。p2 則是一個有著字符串 slice 類型的 x（其值為 "Hello"）和 char 類型的 y（其值為c）的 Point。在 p1 上以 p2 作為參數調用 mixup 會返回一個 p3，它會有一個 i32 類型的 x，因為 x 來自 p1，并擁有一個 char 類型的 y，因為 y 來自 p2。println! 會打印出 p3.x = 5, p3.y = c。

這個例子的目的是展示一些泛型通過 impl 聲明而另一些通過方法定義聲明的情況。這里泛型參數 X1 和 Y1 聲明于 impl 之后，因為它們與結構體定義相對應。而泛型參數 X2 和 Y2 聲明于 fn mixup 之后，因為它們只是相對于方法本身的。

6.泛型代碼性能

不用擔心使用泛型會比使用具體類型的代碼性能低。

Rust 通過在編譯時進行泛型代碼的 單態化（monomorphization）來保證效率。單態化是一個通過填充編譯時使用的具體類型，將通用代碼轉換為特定代碼的過程。

在這個過程中，編譯器尋找所有泛型代碼被調用的位置并使用泛型代碼針對具體類型生成代碼。

下面看看這個怎樣用于標準庫中的 Option 枚舉：

let integer = Some(5);
let float = Some(5.0);

當 Rust 編譯這些代碼的時候，它會進行單態化。編譯器會讀取傳遞給 Option<T> 的值并發現有兩種 Option<T>：一個對應 i32 另一個對應 f64。為此，它會將泛型定義 Option<T> 展開為兩個針對 i32 和 f64 的定義，接著將泛型定義替換為這兩個具體的定義。

編譯器生成的單態化版本的代碼看起來像這樣（編譯器會使用不同于如下假想的名字）：

enum Option_i32 {
    Some(i32),
    None,
}

enum Option_f64 {
    Some(f64),
    None,
}

fn main() {
    let integer = Option_i32::Some(5);
    let float = Option_f64::Some(5.0);
}

泛型 Option<T> 被編譯器替換為了具體的定義。因為 Rust 會將每種情況下的泛型代碼編譯為具體類型，使用泛型沒有運行時開銷。當代碼運行時，它的執行效率就跟好像手寫每個具體定義的重復代碼一樣。這個單態化過程正是 Rust 泛型在運行時極其高效的原因。