Rust語法: 枚舉，泛型，trait

這是我學習Rust的筆記，本文適合于有一定高級語言基礎的開發者看不適合剛入門編程的人，對于一些概念像枚舉，泛型等，不會再做解釋，只寫在Rust中怎么用。

文章目錄

- 枚舉
- - 枚舉的定義與賦值
  - 枚舉綁定方法和函數
  - match匹配枚舉
  - if let語句
  - Option
  - match pattern
  - - 基本pattern
    - pattern守衛
- 泛型
- - 泛型函數
  - 泛型結構體
  - 泛型枚舉
  - 為結構體綁定泛型方法
- trait
- - trait的定義與實現
  - 用trait指定定特定方法
  - impl中的trait約束

枚舉

枚舉的定義與賦值

枚舉的定義格式如下：
enum 枚舉名{
值1(附加類型),
值2(附加類型),…
}
其中，關聯類型可以省去

例如要創建一個神經網絡類型的枚舉，就可以這樣定義

enum NeuralNetwork {CNN,RNN,GAN,Transformer,GNN
}

下面是傳參和創建的例子，其中引用的部分可以看后面的，所有權&生命周期這一部分。

enum NeuralNetwork {CNN,RNN,GAN,Transformer,GNN
}fn main(){let nn1 = NeuralNetwork::CNN; //創建一個NeuralNetwork類型的枚舉，值為CNNlet nn2 = NeuralNetwork::Transformer;let nn3 = nn1;printnn(&nn3); //給函數傳參printnn(&nn2);
}fn printnn(network: &NeuralNetwork){} //實參表明了需要一個NeuralNetwork類型的引用（）

除此之外，枚舉可以增加附類型

enum NeuralNetwork { // 所有的網絡類型都帶有一個附加類型，String表示具體的網絡名CNN(String),RNN(String),GAN(String),Transformer(String),GNN(String)
}
enum Test{ // 所有的網絡類型都帶有一個附加類型，String表示具體的網絡名e1,e2(String), e3{x: u32, y: f64}, //綁定了一個匿名結構體類型e4(u32, u32, u32) //綁定一個Tuple
}fn main(){let nn1 = NeuralNetwork::CNN(String::from("TextCNN")); let nn2 = NeuralNetwork::Transformer(String::from("Transformer-XL"));}

枚舉綁定方法和函數

與結構體類型，對于枚舉，Rust也允許使用impl關鍵字來綁定方法和函數

enum NeuralNetwork {CNN(String),RNN(String),GAN(String),Transformer(String),GNN(String)
}impl NeuralNetwork {fn make_cnn(s: String) -> NeuralNetwork{ //綁定一個函數，用于創建CNN類型枚舉NeuralNetwork::CNN(s)}
}fn main(){let nn1 = NeuralNetwork::make_cnn(String::from("TextCNN"));let nn2 = NeuralNetwork::Transformer(String::from("Transformer-XL"));}

match匹配枚舉

match的語法大致如下

match 變量{
結果1 => 表達式1,
結果2 => 表達式2,
_ => 剩余結果處理
}

enum NeuralNetwork {CNN(String),RNN(String),GAN(String)
}fn main(){let nn1 = NeuralNetwork::CNN(String::from("TextCNN"));match nn1 {NeuralNetwork::CNN(s) => println!("CNN 變體為 {}", s), //匹配到對應類型，后面寫表達式，而括號內的s就是枚舉所綁定類型NeuralNetwork::RNN(s) => println!("RNN 變體為 {}", s),NeuralNetwork::GAN(s) => println!("GAN 變體為 {}", s)}
}

需要注意的是match需要把每一種結果都列出來，如果剩下的不想列可以使用通配符_來表示.

enum NeuralNetwork {CNN(String),RNN(String),GAN(String)
}fn main(){let nn1 = NeuralNetwork::CNN(String::from("TextCNN"));match nn1 {NeuralNetwork::CNN(s) => println!("CNN 變體為 {}", s),_ => println!("非CNN") //剩余類型統一處理}
}

如果箭頭后面需要處理更復雜的邏輯，則可以用函數塊來寫，如下

enum NeuralNetwork {CNN(String),RNN(String),GAN(String)
}fn main(){let nn1 = NeuralNetwork::CNN(String::from("TextCNN"));match nn1 {NeuralNetwork::CNN(s) => {let len = s.len();println!("CNN 變體為 {} {}", s, len);},_ => println!("非CNN");}
}

除此之外match其實是有返回值的，正如函數塊的最后一個運算式為返回值一樣，match的返回值為=>后的值

enum NeuralNetwork {CNN(String),RNN(String),GAN(String)
}fn main(){let nn1 = NeuralNetwork::CNN(String::from("TextCNN"));let res = match nn1 {NeuralNetwork::CNN(s) => {println!("CNN 變體為 {}", s);s //s是返回值，返回給res，下面同理},NeuralNetwork::RNN(s) => {println!("RNN 變體為 {}", s);s},NeuralNetwork::GAN(s) => {println!("GAN 變體為 {}", s);s}};println!("res is {}", res)
}

除了枚舉之外，match也可以匹配別的值

fn main(){let x = 10;match x {1 => println!("Is one!"),2 => println!("Is tow"),_ => println!("Other number!")};
}

fn main(){let x = "adasdasd";match x {"abc" => println!("Is abc!"),"efg" => println!("Is efg"),_ => println!("Other string!")};
}

if let語句

如果指向match一種情況，則可以使用if let這個語法糖，只針對一種模式進行匹配

enum NeuralNetwork {CNN(String),RNN(String),GAN(String)
}fn main(){let nn1 = NeuralNetwork::CNN(String::from("TextCNN"));if let nn1 = NeuralNetwork::CNN{println!("是CNN");}
}

注意，if let后面的判斷是=，而不是==。如果想要處理剩余情況，可以再加一個else

enum NeuralNetwork {CNN(String),RNN(String),GAN(String)
}fn main(){let nn1 = NeuralNetwork::CNN(String::from("TextCNN"));if let nn1 = NeuralNetwork::CNN{println!("是CNN");}else{println!("不是CNN");}
}

Option

Option是一種枚舉，包含兩種類型，分別是Some和None。Rust設計Option就是為了避免None和其它的值做運算而造成一系列錯誤而設計的。
Option的定義大致如下：

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

Option可以如下使用

fn main(){let x = Option::Some("hello");let y: Option<&str>= Option::None; //這里屬于泛型，需要指定Option的泛型類型let z = x + y; // None無法和y運算，從而保證了安全性
}

fn main(){let _x = Option::Some("hello");let y: Option<&str> = None;match y {Option::None => println!("空的"),Option::Some(t) => println!("非空, 是{}", t)}
}

match pattern

基本pattern

match允許更為復雜的匹配，這稱之為匹配的pattern，其中常用的操作如下：

| 用于分割多個可能，Rust會從左到右依次檢查是否符合

例如：a | b | c則會檢查a后檢查b，再檢查是否符合c

()元組用于實現匹配坐標這類的多個參數數據
可以用…=b, a…=b這種Range來進行范圍的匹配

注意，a…b是左閉右開類型，而加上等號則是左閉右閉

_可以用來匹配剩余未匹配的所有值

fn main(){let x: i32 = 100;match x {1 | 2 | 3 => println!("x位于1到3之間"), //會依次檢查x是1,2還是3.只要匹配一個就進入后面的語句4 ..=9 => println!("x位于4到9之間"),10 | 100..=1000 => println!("x為10，或者100-1000之間的數"),_ => println!("x不是所期待的數字")};
}

fn main(){let x: (i32, i32) = (-9, -10);match x {(1, 1) => println!("點(1, 1)"),(1, 2 | 3 | 4) => println!("點(1,2), (1,3)或((1,4))"),(..=-1, ..=-1) => println!("第三象限的點"),_ => println!("其他區域的點")};
}

可以使用@符號把必要時的某個值綁定到變量上，操作為變量 @ 匹配式

fn main(){let x: (i32, i32) = (-9, -10);match x {(1, 1) => println!("點(1, 1)"),(1, 2 | 3 | 4) => println!("點(1,2), (1,3)或((1,4))"),(x @ ..=-1, y @ ..=-1) => println!("第三象限的點({}, {})", x, y), //綁定第一個空的值到x，同理綁定y。_ => println!("其他區域的點")};
}

pattern守衛

pattern后面可以加上if判斷語句來進一步的判斷這個匹配是否合法，示例如下

fn judge_prime(x: i32) -> bool{// TODO: 判斷素數true
}
fn main(){let tmp: (i32, i32) = (-9, -10);match tmp {(x @ 0..=10, y @ _) if x == y => println!("在y=x直線上(0 <= x <= 100)"),(x @ 0..=100, y @ 0..=100) if judge_prime(x) && judge_prime(y) => println!("(x, y)為0-100內的素數坐標"),_ => println!("")};
}

當然if后面的語句可以替換成函數塊{}只要其返回值是bool類型即可。

fn judge_prime(_x: i32) -> bool{// TODO: 判斷素數true
}fn main(){let tmp: (i32, i32) = (-9, -10);match tmp {(x, y) if x == y => println!("在y=x直線上"), //此時x，y無綁定，也就是無綁定上的約束(x @ 0..=100, y @ 0..=100) if {let tmp: bool = judge_prime(x);tmp && judge_prime(y)}=> println!("(x, y)為0-100內的素數坐標"),_ => println!("")};
}

泛型

如其他語言（CPP，JAVA）一樣，Rust也支持泛型。

泛型函數

泛型函數需要在函數名上指明泛型類型，通常用T，U這種大寫字母來表示

fn qpow<T>(base: T, p: i32) -> T{//TODO實現快速冪的邏輯
}

上述函數中T表示某個抽象的類型，而這個類型需要在函數名部分標注出來。隨后的base和返回值都是T類型。
當然涉及到兩個或者多個翻新類型時，需要都在函數名后面聲明出

fn Test<T, U>(x: T, y: U) -> (T, U){//TODO
}

泛型結構體

與函數類似，可以在結構體明上聲明某個或者多個抽象類型

struct Point<T>{x: T,y: T
}
fn main(){let ip = Point{x: 10, y: 10}; //此時ip類型為Point<i32>let fp = Point{x: 10.0, y: 11.1};//此時ip類型為Point<f64>
}

注意，Rust在編譯時會把所有的抽象類型T替換成具體的類型，因為Rust是靜態的，所以在編譯之后所有的抽象類型都已經有具體的確定類型的值了。

struct Point<T>{x: T,y: T
}
fn main(){let ip: Point<i64> = Point{x: 10, y: 10}; //強制約束為i64let fp = Point{x: 10.0, y: 11};//報錯，因為有兩個類型
}

泛型枚舉

枚舉的泛型就是把其變體所綁定的類型內添加泛型，前面的Option的Some就是這個原理。

enum Test<T, U> {SOME(T, U),OTHER(T),NO

為結構體綁定泛型方法

為結構體綁定方法使用impl關鍵字，如果該結構體是一個泛型結構體，則需要再impl后面加表明抽象類型。

struct Point<T>{x: T,y: T    
}impl Point<i32> { //只為i32類型實現判斷素數坐標的方法, 由于是實現具體類型所以不需要再impl后面加尖括號fn judge_prime(&self) -> bool{//TODO判斷素數}
}impl<T> Point<T> { //為所有類型都實現一個畫圖的方法，抽象方法要加尖括號表明抽象類型fn show_point(&self) -> (){//TODO畫圖}
}

注意，此時impl的泛型參數不影響具體方法的參數

struct Point<T, U>{x: T,y: U
}impl<T, U> Point<T, U> {fn make_new_point<W>(&self, other_point: Point<T, W>) -> Point<T, W>{Point { x: self.x.clone(),  //這里會有報錯，具體原因看后面的trait部分y: other_point.y }}
}fn main(){
}

trait

trait的定義與實現

trait是Rust的一個類似于接口的類型，他可以為enum，struct來定義一套標準的接口，或者默認的某些方法。

trait 名字{
函數|抽象函數
}

看下面的例子

trait Draw {fn _draw_atom(&self) ->(); //實現單個點的繪畫，是一個抽象的方法fn draw(&self) -> (){ //draw繪畫調用_draw_atom，是一個已經實現的方法self._draw_atom()}
}

使用

impl trait類型 for 結構體|枚舉

來為結構體或者枚舉綁定方法

struct Point{x: f64,y: f64
}struct Line{A: f64,B: f64
}trait Draw {fn _draw_atom(&self) ->();fn draw(&self) -> (){ //該方法為所有實現Draw trait的結構體/枚舉所共有self._draw_atom()}
}impl Draw for Point { //為Point結構體實現fn _draw_atom(&self) ->() {println!("{} {}", self.x, self.y);}
}impl Draw for Line {//為Line結構體實現fn _draw_atom(&self) -> (){println!("{}x + {}y = 0", self.A, self.B);}
}

用trait指定定特定方法

首先對于簡單的約束，我們可以直接在函數參數后面加上 impl trait類型 的方式來要求某個參數必須實現特定的trait

fn Test(x: impl Draw){ //約束x必須實現Draw
}

如果類型比較多，且復雜則可以使用Bound的方式具體做法如下

在函數名后面用尖括號，寫上泛型，然后后面用冒號指定trait
函數名<T: trait1 + traiit2+…, U: trait1+traitk…>

use std::fmt::Display; //使用fmt內的Display trait
fn Test<T: Draw + Display, U: Display>(x: T, y: U){} 
//要求x實現了Draw和Display兩個trait，而y只要求實現Display這個trait

此時你會發現bound約束太長了，降低了函數的可讀性。于是Rust允許使用where關鍵字把Bound約束后置, 具體做法如下

在函數尖括號后聲明泛型，T，U等變量。
在函數的函數體前用where關鍵字，后面跟上每個泛型變量的約束trait

use std::fmt::Display;
fn Test<T, U>(x: T, y: U)
whereT: Draw + Display, //約束TU: Display //約束U
{//TODO：函數體
}

我們同樣可以再返回類型上約束實現具體的trait。但此時需要注意，返回的類型必須要是一種類型，不能使用分支語句使其返回多種可能的類型

use std::fmt::Display;
fn Test<T, U>(x: T, y: U) -> U //返回類型必須實現了Display
whereT: Draw + Display, //約束TU: Display //約束U
{//TODO：函數體
}

impl中的trait約束

除此之外，在impl中的泛型T，也可以進行相對應的trait的約束

impl<T: Display> Point<T>{ 
//對所有實現了Display trait的類型T，其Point<T>都會具有test方法fn test(&self){}}

trait可以進行覆蓋實現，也就是為所有實現某些trait的類型添加一些方法


trait Hello {fn print_hello(){println!("hello");}
}impl<T: std::fmt::Display> Hello for T{//為所有實現了Display這個trait的類型都添加一個print_hello函數}
fn main(){i32::print_hello(); //此時實現了Display的i32類型，也可以調用這個方法了
}