2311rust模式匹配

原文

在Rust中混合匹配,改变和移动

结构模式匹配:极大的改进了C或Java风格的switch语句.

Match包含命令式和函数式编程风格:可继续使用break语句,赋值等,不必面向表达式.
按需匹配"借用"或"移动",:Rust鼓励开发者仔细考虑所有权和借用.设计匹配时仅支持借用子结构(而不是总移动).

基本匹配

Rust中的match(匹配)式有以下形式:

match INPUT_EXPRESSION {PATTERNS_1 => RESULT_EXPRESSION_1,PATTERNS_2 => RESULT_EXPRESSION_2,...PATTERNS_n => RESULT_EXPRESSION_n
}

其中每个PATTERNS_i至少包含一个模式.模式描述了INPUT_EXPRESSION可计算到的可能值的子集.语法PATTERNS=>RESULT_EXPRESSION叫"匹配分支",或简叫"分支".

模式可匹配如整数或符等简单值;还可通过枚举定义匹配用户定义的符号数据.
示例:

enum Answer {Higher,Lower,Bingo,
}
fn suggest_guess(prior_guess: u32, answer: Answer) {match answer {Answer::Higher => println!("maybe try {} next", prior_guess + 10),Answer::Lower  => println!("maybe try {} next", prior_guess - 1),Answer::Bingo  => println!("we won with {}!", prior_guess),}
}
#[test]
fn demo_suggest_guess() {suggest_guess(10, Answer::Higher);suggest_guess(20, Answer::Lower);suggest_guess(19, Answer::Bingo);
}

模式还可用(如元组,切片,结构)相应模式匹配结构化数据.绑定部分输入到局部变量;然后,可在结果式中使用这些变量.

struct GuessState {guess: u32,answer: Answer,low: u32,high: u32,
}
fn suggest_guess_smarter(s: GuessState) {match s {GuessState { answer: Answer::Bingo, guess: p, .. } => {
//..匹配值序列或名值对println!("we won with {}!", p);}GuessState { answer: Answer::Higher, low: _, guess: l, high: h } |GuessState { answer: Answer::Lower,  low: l, guess: h, high: _ } => {
//_匹配单值,作为最后的默认.
//|表示`或者`.let mid = l + ((h - l) / 2);println!("lets try {} next", mid);}}
}
#[test]
fn demo_guess_state() {suggest_guess_smarter(GuessState {guess: 20, answer: Answer::Lower, low: 10, high: 1000});
}

编译时拒绝以下代码.

fn suggest_guess_broken(prior_guess: u32, answer: Answer) {let next_guess = match answer {Answer::Higher => prior_guess + 10,Answer::Lower  => prior_guess - 1,//错误:未完整匹配.};println!("maybe try {} next", next_guess);
}

修复

fn suggest_guess_fixed(prior_guess: u32, answer: Answer) {let next_guess = match answer {Answer::Higher => prior_guess + 10,Answer::Lower  => prior_guess - 1,Answer::Bingo  => {println!("we won with {}!", prior_guess);return;}//补上最后分支};println!("maybe try {} next", next_guess);
}
#[test]
fn demo_guess_fixed() {suggest_guess_fixed(10, Answer::Higher);suggest_guess_fixed(20, Answer::Lower);suggest_guess_fixed(19, Answer::Bingo);
}

代数数据类型和结构不变量

代数数据类型简要描述了数据类,并允许丰富的结构不变量.
在Rust中,枚举可定义更加丰富的数据类.
如,二叉树或为叶,或为引用两个子树的内部节点.构建树:

enum BinaryTree {Leaf(i32),Node(Box<BinaryTree>, i32, Box<BinaryTree>)
}

Box<V>描述了拥有堆分配的V实例引用;如果拥有Box<V>,则也就拥有了它所包含的V,且可改变它,借出引用等等.

完成Box并出域时,自动清理与堆分配的V实例关联的资源.

上面的枚举定义确保,如果得到一个BinaryTree,将总是属于上述二者之一.永远不会遇见无左子的BinaryTree::Node.因此无需检查null.

但确实要检查给定的BinaryTree是Leaf还是Node,但编译器会静态确保此类检查:你不会意外地按节点解释Leaf数据,反之亦然.

如下使用match对树中的所有整数求和:

fn tree_weight_v1(t: BinaryTree) -> i32 {match t {BinaryTree::Leaf(payload) => payload,BinaryTree::Node(left, payload, right) => {tree_weight_v1(*left) + payload + tree_weight_v1(*right)}}
}///返回如下的树:
///      +----(4)---+
///      |          |
///   +-(2)-+      [5]
///   |     |   
///  [1]   [3]
fn sample_tree() -> BinaryTree {let l1 = Box::new(BinaryTree::Leaf(1));let l3 = Box::new(BinaryTree::Leaf(3));let n2 = Box::new(BinaryTree::Node(l1, 2, l3));let l5 = Box::new(BinaryTree::Leaf(5));BinaryTree::Node(n2, 4, l5)
}
#[test]
fn tree_demo_1() {let tree = sample_tree();assert_eq!(tree_weight_v1(tree), (1 + 2 + 3) + 4 + 5);
}

代数数据类型创建语言严格执行的结构不变量.

既面向表达式,也面向语句

下面的代码使用区间模式来简化,编写风格类似面向语句语言(如C(或C++,Java等)中的开关(switch)),其中仅针对该分支执行匹配:

fn num_to_ordinal(x: u32) -> String {let suffix;match (x % 10, x % 100) {(1, 1) | (1, 21...91) => {suffix = "st";}(2, 2) | (2, 22...92) => {suffix = "nd";}(3, 3) | (3, 23...93) => {suffix = "rd";}_                     => {suffix = "th";}}return format!("{}{}", x, suffix);
}
#[test]
fn test_num_to_ordinal() {assert_eq!(num_to_ordinal(   0),    "0th");assert_eq!(num_to_ordinal(   1),    "1st");assert_eq!(num_to_ordinal(  12),   "12th");assert_eq!(num_to_ordinal(  22),   "22nd");assert_eq!(num_to_ordinal(  43),   "43rd");assert_eq!(num_to_ordinal(  67),   "67th");assert_eq!(num_to_ordinal(1901), "1901st");
}

静态分析确保:
1,总是在在函数尾,格式!之前初化后缀.
2,执行函数时,最多分配一次后缀.(如果是多次,编译器会提醒你),
面向表达式,则如下:

fn num_to_ordinal_expr(x: u32) -> String {format!("{}{}", x, match (x % 10, x % 100) {(1, 1) | (1, 21...91) => "st",(2, 2) | (2, 22...92) => "nd",(3, 3) | (3, 23...93) => "rd",_     => "th"})
}

想要初化某个状态,然后借用它时,但仅限于某些控制流分支.

fn sometimes_initialize(input: i32) {let string: String; //动态构造串值let borrowed: &str; //引用串数据match input {0...100 => {//临时构造串...string = format!("input prints as {}", input);//...然后从中借用.borrowed = &string[6..];}_ => {//串字面是*已*借用的引用borrowed = "期望0 and 100间";}}println!("borrowed: {}", borrowed);//println!("string: {}", string);//取消上面注释,会报错.借用已借用了串,你不能再用了.
}
#[test]
fn demo_sometimes_initialize() {sometimes_initialize(23);  //此调用初化"串`"`,sometimes_initialize(123); //此调用不会
}

有趣在,匹配后,禁止直接访问串,因为在访问前,必须在每个路径上初化变量.
但,可用borrowed访问串中数据,因为确保已初化了该串.
编译器确保借用的串数据不会超过串自身,且生成代码确保在串域尾,如果已初化它,则会释放它.

总之,为了健壮性,Rust语言确保在引用数据前,总是初化它.

匹配而不移动

匹配输入可不取所有权,直接借用输入;对匹配引用(如&T)至关重要.

上面版本的tree_weight有个很大的缺点:它按值取输入树.一旦传递一棵树给tree_weight_v1,这棵树就消失了(如,释放).

#[test]
fn tree_demo_v1_fails() {let tree = sample_tree();assert_eq!(tree_weight_v1(tree), (1 + 2 + 3) + 4 + 5);//assert_eq!(tree_weight_v1(tree), (1 + 2 + 3) + 4 + 5);//取消注释,会报错.
}

然而,这不是匹配造成的;而是函数签名:

fn tree_weight_v1(t: BinaryTree) -> i32 { 0 }
//即此函数拥有了`'t'`的所有权

在Rust中,匹配不取所有权,也良好运行.即,要匹配的输入是左值式.
匹配,执行此求值,然后检查该内存位置的数据.
(如果输入式是变量名或字段/指针解引用,则左值只是该变量或字段/内存的位置.如果输入式是生成未命名临时值的函数调用或其他操作,则存储在匹配检查的临时区域(内存位置)中.)

因此,如果仅想借用一棵树而不拥有它的tree_weight版本,则需要利用Rust匹配的该特性.

fn tree_weight_v2(t: &BinaryTree) -> i32 {//表示正在*借用*树,&表示借用.match *t {//解引用BinaryTree::Leaf(payload) => payload,BinaryTree::Node(ref left, payload, ref right) => {//引用分支的引用绑定.tree_weight_v2(left) + payload + tree_weight_v2(right)}}
}
#[test]
fn tree_demo_2() {let tree = sample_tree();assert_eq!(tree_weight_v2(&tree), (1 + 2 + 3) + 4 + 5);
}

该tree_weight_v2函数非常像tree_weight_v1.唯一的区别是:t是借用的引用(用&),并添加了*t解引用,重要的是,对Node的left和right使用引用绑定.

(按左值式)解引用*t,只是取表示BinaryTree的内存地址(因为t:&BinaryTree只是引用内存中的该数据).
*t不是复制树,也不是移动到新的临时位置,因为match按左值对待它.

引用绑定
首先,非引用绑定的含义:
匹配T类型值时,在成功匹配时,i标识模式把值从原始输入移出并移入i.因此,此时,i有T型(或"i:T").

对可复制T(实现Copy的T),该模式绑定表明i变量拥有T类型值的所有权.

因此,tree_weight_v2中负载的绑定都有i32类型;i32类型实现了Copy,因此把权重复制到两个分支的负载中.

而引用绑定:

匹配T类型左值时,在成功匹配时,引用绑定(ref i),只会借用匹配数据的引用.即,成功匹配T类型值的ref i表明i借用T的引用(即,"i:&T").

因此,在tree_weight_v2的Node分支中,left,引用(包含一棵树的)左边树,而right则引用右边树.
在递归调用tree_weight_v2中,可传递这些引用.
同样,在成功匹配时,可变引用借用输入的可变引用:即i:&mut T.这允许改变,并确保同时无其他活动的该数据引用.
match的此解构绑定形式,允许你同时取数据的不相交部分的可变引用.

如下递增给定树中的所有值.

fn tree_grow(t: &mut BinaryTree) {//mut':独占权match *t {BinaryTree::Leaf(ref mut payload) => *payload += 1,BinaryTree::Node(ref mut left, ref mut payload, ref mut right) => {tree_grow(left);//加左*payload += 1;tree_grow(right);//加右}}
}
#[test]
fn tree_demo_3() {let mut tree = sample_tree();tree_grow(&mut tree);assert_eq!(tree_weight_v2(&tree), (2 + 3 + 4) + 5 + 6);
}

注意,现在通过可变引用绑定有效负载;如果不用引用,则负载绑定到整数的本地副本,但想修改树自身中实际整数.就需要用该整数的引用.

注意,代码可在Node分支中,可同时绑定左右.编译器知道这两个值不是别名,因此允许同时存在两个&mut引用.

更多:
1,在模式中,如何用Higher而不是Answer::Higher,
2,定义新的命名常量,
3,通过ident @ pattern绑定
4,

{ let id = expr; ... }
//与如下的区别:
match expr { id => { ... } }