泛型

有時候，寫一個函數(shù)或數(shù)據(jù)類型時，我們可能希望它可以作為多種類型的工作參數(shù)。幸運的是，Rust 給我們提供了一種更好地解決辦法：泛型。在類型理論中，泛型類型被稱為“參數(shù)多態(tài)性”，這意味著在給定參數(shù)(變量)的情況下，他們是具有多種形式的類型或函數(shù) (“聚”是多個“變形”形式)。

不管怎樣，類型理論已經(jīng)足夠充分,讓我們看看一些通用的代碼。Rust 的標準庫提供了一個類型， Option<T>,這是通用的：

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

< T > 部分。正如你之前已經(jīng)見到過的，表明這是一個通用的數(shù)據(jù)類型。在我們枚舉的聲明里面，無論我們在哪里看到 T，我們用泛型中相同的數(shù)據(jù)類型來作為那個數(shù)據(jù)類型的替代品。這里有一個使用 Option<T> 的例子，與一些額外的類型注解：

let x: Option<i32> = Some(5);

在類型聲明里面，我們用 Option<i32>。請注意它與 Option<T> 看起來非常類似。所以,在這個特殊的選項 T 中，T 的值為 i32。在等號的右邊,有一個 some(T)，T 的值是 5。因為這是一個 i32，所以雙方能夠匹配。此時 Rust 運行沒有錯誤。如果他們不匹配,我們會得到一個錯誤：

let x: Option<f64> = Some(5);
// error: mismatched types: expected `core::option::Option<f64>`,
// found `core::option::Option<_>` (expected f64 but found integral variable)

這并不意味著我們不能讓 Option<T>s 的值為 f64 !他們必須匹配才可以：

let x: Option<i32> = Some(5);
let y: Option<f64> = Some(5.0f64);

這樣很好。因為一個定義，可以用于多個用途。

泛型不必只是通用的一種類型?？紤] Rust 的標準庫里面的另一種相似的類型，Result<T, E>

enum Result<A, Z> {
Ok(A),
Err(Z),
}

這個類型對這兩種類型都是通用的：T 和 E,順便說一下，大寫字母可以是任何你喜歡的字母。我們可以定義 Result<T, E >如下：

enum Result<A, Z> {
Ok(A),
Err(Z),
}

如果我們想要這樣。公約說，第一個通用的參數(shù)應該是 T，它對應于“類型”，我們使用 E 對應于 error。然而，Rust 并不關心這些。

Result<T, E> 類型的作用是用于返回計算的結果，并能夠在發(fā)生差錯的時候返回一個錯誤。

通用函數(shù)

我們可以用相似的語法編寫帶有泛型的函數(shù)：

fn takes_anything<T>(x: T) {
// do something with x
}

語法分為兩個部分：< T > 表示“這個函數(shù)對類型 T” 是通用，和 x:T 表示“x 的類型為 T .”

多個參數(shù)可以有相同的泛型類型：

fn takes_two_of_the_same_things<T>(x: T, y: T) {
// ...
}

我們可以寫一個擁有多種類型的版本：

fn takes_two_things<T, U>(x: T, y: U) {
// ...
}

對于特征邊界來說通用函數(shù)是最有用的，我們將在特征部分討論它。

通用結構

你可以存儲一個泛型類型的結構：

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

let int_origin = Point { x: 0, y: 0 };
let float_originstruct Point<T> {
x: T,
y: T,
}

let int_origin = Point { x: 0, y: 0 };
let float_origin = Point { x: 0.0, y: 0.0 };

類似于函數(shù)，< T > 是我們聲明泛型參數(shù)的地方，然后，我們在類型聲明里使用 x:T。