doc: add some content in the rust.md (#50)

docs/rust.md

@@ -163,6 +163,31 @@ let baz_discriminant = Foo::Baz as u32;
 assert_eq!(baz_discriminant, 123);
 ```
 
+### 语句与表达式
+
+在 rust 中，语句无需返回值，而表达式总要返回值
+
+#### 语句
+
+```rust
+let a = "hello".to_string();
+let b = a + " world";
+println!("{}", b);
+```
+
+#### 表达式
+
+```rust
+fn main(){
+    let x = {
+        let a = "hello".to_string();
+        a + " world"
+    };
+    println!("{}", x);
+    // hello world
+}
+```
+
 Rust 类型
 --------
 
@@ -535,29 +560,7 @@ let mut l = k;
 Rust 流程控制
 ------------
 
-### If表达式
+### If 表达式
-
-```rust
-let case1: i32 = 81;
-let case2: i32 = 82;
-if case1 < case2 {
-  println!("case1 大于 case2");
-}
-```
-
-### If...Else 表达式
-
-```rust
-let case3 = 8;
-let case4 = 9;
-if case3 >= case4 {
-  println!("case3 优于 case4");
-} else {
-  println!("case4 大于 case3");
-}
-```
-
-### If...Else...if...Else 表达式
 
 ```rust
 let foo = 12;
@@ -573,101 +576,30 @@ if foo == bar {
 }
 ```
 
-### If...let 表达式
-<!--rehype:wrap-class=row-span-3-->
-
-```rust
-let mut arr1:[i64 ; 3] = [1,2,3];
-if let[1,2,_] = arr1{
-    println!("与数组一起使用");
-}
-let mut arr2:[&str; 2] = ["one", "two"];
-if let["Apple", _] = arr2{
-    println!("也适用于 str 数组");
-}
-```
-
-----
-
-```rust
-let tuple_1 = ("India", 7, 90, 90.432);
-if let(_, 7, 9, 78.99) = tuple_1{
-    println!("也适用于元组");
-}
-let tuple_2 = ( 9, 7, 89, 12, "Okay");
-if let(9, 7,89, 12, blank) = tuple_2 {
-    println!("一切{blank}伴侣？");
-}
-let tuple_3 = (89, 90, "Yes");
-if let(9, 89, "Yes") = tuple_3{
-    println!("模式确实匹配");
-}
-else {
-    println!("模式不匹配");
-}
-```
-
-### 匹配表达式
-<!--rehype:wrap-class=row-span-3-->
-
-```rust
-let day_of_week = 2;
-match day_of_week {
-  1 => {
-    println!("兄弟们今天是星期一");
-  },
-  2 => {
-    println!("兄弟们今天是星期二");
-  },
-  3 => {
-    println!("兄弟们今天是星期三");
-  },
-  4 => {
-    println!("兄弟们今天是星期四");
-  },
-  5 => {
-    println!("兄弟们今天是星期五");
-  },
-  6 => {
-    println!("兄弟们今天是星期六");
-  },
-  7 => {
-    println!("兄弟们今天是星期天");
-  },
-  _ => {
-    println!("默认!")
-  }
-};
-```
-
-### 嵌套...If 表达式
-
-```rust
-let nested_conditions = 89;
-if nested_conditions == 89 {
-    let just_a_value = 98;
-    if just_a_value >= 97 {
-        println!("大于 97");
-    }
-}
-```
-
 ### For 循环
+<!--rehype:wrap-class=col-span-2-->
 
 ```rust
-for mut i in 0..15 {
+let mut vec = [1, 2, 3];
-  i-=1;
+for v in &mut vec {
-  println!("i 的值为：{i}");
+  *v -= 1;
+  println!("v 的值为：{v}");
 }
 ```
 
+使用方法                      | 等价使用方式                         | 所有权
+:-|:-:|:-
+for item in collection      | for item in collection.into_iter() | 转移所有权
+for item in &collection     | for item in collection.iter()      | 不可变借用
+for item in &mut collection | for item in collection.iter_mut()  | 可变借用
+
 ### While 循环
 
 ```rust
 let mut check =  0;
 while check < 11{
   println!("check 是：{check}");
-  check+=1;
+  check += 1;
   println!("递增后：{check}");
   if check == 10{
     break; // 停止 while
@@ -675,7 +607,7 @@ while check < 11{
 }
 ```
 
-### Loop 关键字
+### Loop 循环
 
 ```rust
 loop {
@@ -685,19 +617,6 @@ loop {
 
 无限循环表示
 
-### Break 中断语句
-
-```rust
-let mut i = 1;
-loop {
-  println!("i 是 {i}");
-  if i > 100 {
-    break;
-  }
-  i *= 2;
-}
-```
-
 ### Continue 继续声明
 
 ```rust
@@ -711,118 +630,279 @@ for (v, c) in (0..10+1).enumerate(){
 }
 ```
 
+### Break 中断语句
+
+`break` 可以单独使用，也可以带一个返回值
+
+```rust
+let mut i = 1;
+let res = loop {
+  println!("i 是 {i}");
+  if i > 100 {
+    break i - 100;
+  }
+  i *= 2;
+}
+
+println!("{res}"); // 28
+```
+
+Rust 模式匹配
+--------
+
+### match
+<!--rehype:wrap-class=row-span-2-->
+
+match 模式匹配，使用 `a | b` 表示匹配 a **或** b，使用 `_`，表示匹配剩余所有选项
+
+```rust
+fn main(){
+    let grade = Grade::A;
+    match grade {
+        Grade::A => println!("Good"),
+        Grade::B => println!("Not bad"),
+        Grade::C | Grade::D => println!("Come on"),
+        _ => println!("emmm"),
+    }
+}
+
+enum Grade {
+    A,
+    B,
+    C,
+    D,
+    E,
+    F,
+}
+```
+
+#### `matches!` 宏
+
+它可以将一个表达式跟模式进行匹配，然后返回匹配的结果 `true` 或 `false`
+
+```rust
+assert!(matches!('x' ',A'..='Z' | 'a'..='z'));
+assert!(matches!(Some(101), Some(x) if x > 100));
+```
+
+### if let 匹配
+
+match 表达式需要匹配所有的枚举才能结束，但通常我们只需要匹配我们需要的值
+
+```rust
+let x = 3;
+match Some(x) {
+    Some(3) => println!("I guess that x is 3"),
+    _ => ()
+}
+```
+
+使用 `if let`
+
+```rust
+let x = 3;
+if let Some(3) = Some(x) {
+    println!("I guess that x is 3");
+}
+```
+
+### while let
+
+```rust
+let mut stack = vec![];
+
+stack.push(1);
+stack.push(2);
+stack.push(3);
+
+while let Some(top) = stack.pop() {
+    println!("{}", top);
+}
+```
+
+### 其它模式匹配
+
+#### for 循环迭代器
+
+```rust
+for (i, v) in collection.iter().enumerate(){}
+```
+
+#### let
+
+```rust
+let (x, _, y) = (1, 2, 3);
+println!("{x},{y}");
+```
+
+### 函数中的模式匹配
+
+```rust
+fn add((x, y): (i32, i32)) -> i32 {
+    x + y
+}
+fn main(){
+  let sum = add(1, 2);
+  println!("{sum}");
+}
+```
+
+### 忽略参数
+<!--rehype:wrap-class=row-span-2-->
+
+#### 使用 `..` 忽略剩余参数
+
+```rust
+struct Point {
+    x: i32,
+    y: i32,
+    z: i32,
+}
+
+let origin = Point { x: 0, y: 0, z: 0 };
+
+match origin {
+    Point { x, .. } => println!("x is {}", x),
+}
+```
+
+#### 使用 `_` 忽略部分参数
+
+```rust
+let hello = ('h', 'e', 'l', 'l', 'o');
+
+match hello {
+    (h, _, _, l, o) => {
+        println!("char: {}, {}, {}", h, l, o)
+    },
+}
+```
+
+### 匹配命名变量
+
+以下代码，只要给定的 x 是 Some 类型，但 Some 中的值不是 1，都会匹配到 y
+
+```rust
+let x = Some(10);
+match x {
+    Some(1) => println!("x = 1"),
+    Some(y) => println!("y = {:?}", y),
+    _ => println!("None"),
+}// y = 10
+```
+
+### `@` 绑定
+<!--rehype:wrap-class=row-span-2-->
+
+`@` 运算符允许为一个字段绑定另外一个变量。
+
+```rust
+let grade = 'A';
+match grade {
+    good @ 'A'..='C' => println!("your grade is {}", good),
+    _ => println!("Come on"),
+}
+```
+
+----
+
+```rust
+#[derive(Debug)]
+struct Point {
+    x: i32,
+    y: i32,
+}
+fn main(){
+    let p @ Point {x: px, y: py } = Point {x: 10, y: 23};
+    println!("x: {}, y: {}", px, py);
+    println!("{:?}", p);
+}
+```
+
+----
+
+如果使用 `|`，需要使用 `()`，进行多个模式的绑定
+
+```rust
+match 1 {
+    num @ (1 | 2) => {
+        println!("{}", num);
+    }
+    _ => {}
+}
+```
+
+### 使用匹配守卫
+
+```rust
+let x = Some(2);
+match x {
+    Some(1) => println!("x = 1"),
+    Some(y) if y == 2 => println!("y = {:?}", y),
+    _ => println!("No match"),
+}// y = 2
+```
+
 Rust 函数
 --------
 
-### 基本函数
+### 函数命名
+
+rust 的函数使用蛇形命名法（snake case）
 
 ```rust
 fn print_message(){
   println!("Hello, Quick Reference!");
 }
-fn main(){
-  // 在 Rust 中调用函数
-  print_message();
-}
 ```
 
-### 按值传递
+### 参数值
+
+rust 需要为函数的参数标明确定的类型
 
 ```rust
-fn main()
+fn another_fn(a:u8, b: &str){
-{
+    println!("我是 u8:{}", a);
-  let x:u32 = 10;
+    println!("我是 &str:{}", b);
-  let y:u32 = 20;
-  
-  // => 200
-  println!("计算: {}", cal_rect(x, y));
 }
-fn cal_rect(x:u32, y:u32) -> u32
+
-{
+fn main(){
-  x * y
+    another_fn(10, "hello")
 }
 ```
 
-### 通过引用传递
+### 返回值
+
+如果不指定返回值，rust 默认返回 `()` 类型
 
 ```rust
-fn main(){
+// 在 bin 中的入口函数默认返回 ()
-  let mut by_ref = 3;      // => 3
+fn main(){}
-  power_of_three(&mut by_ref);
-  println!("{by_ref}");  // => 9
-}
-fn power_of_three(by_ref: &mut i32){
-  // 取消引用很重要
-  *by_ref = *by_ref * *by_ref;
-  println!("{by_ref}");  // => 9
-}
 ```
 
-### 返回
+----
+
+使用 `->` 指定返回值，如果**表达式**在最后一行，无需使用 return
 
 ```rust
-fn main(){
+fn add(a:i32, b:i32) -> i32 {
-  let (mut radius, mut pi) = (3.0, 3.14);
+    if a + b < 100 {
-  let(area, _perimeter) = calculate (
+        return a - b;
-      &mut radius,
+    }
-      &mut pi
+    a + b
-  );
-  println!("圆的面积和周长为：{area} & {_perimeter}");
-}
-fn calculate(radius : &mut f64, pi: &mut f64) -> (f64, f64){
-  let perimeter = 2.0 * *pi * *radius;
-  let area = *pi * *radius * *radius;
-  return (area, perimeter);
 }
 ```
+
+### 永不返回 `!`
+
+```rust
+fn dead_end() -> ! {
+    panic!("panic!!!!!");
+}
+```
+
 <!--rehype:className=wrap-text -->
 
-### 数组作为参数
-
-```rust
-fn main(){
-  let mut array: [i32 ; 5] = [1,2,3,4,6];
-  print_arrays(array);
-  println!("元素：{array:?}");
-}
-fn print_arrays(mut array:[i32; 5]) {
-  array[0] = 89;
-  array[1] = 90;
-  array[2] = 91;
-  array[3] = 92;
-  array[4] = 93;
-  println!("元素：{array:?}");
-}
-```
-
-### 返回数组
-
-```rust
-fn main(){
-  let mut arr:[i32; 5] = [2,4,6,8,10];
-  multiply(arr);
-  println!("数组是：{:?}", multiply(arr));
-}
-fn multiply (mut arr: [i32 ; 5]) -> [i32 ; 5]{
-  arr[2] = 90;
-  for mut i in 0..5 {
-      arr[i] = arr[i] * arr[2];
-  }
-  return arr;
-}
-```
-<!--rehype:className=wrap-text -->
-
-### 泛型函数
-
-```rust
-use std::fmt::Debug;
-fn foo<T>(x: &[T]) where T: Debug {
-    // 省略细节
-}
-foo(&[1, 2]);
-```
-
 杂项
 -----