doc: add strcut and enum in the rust (#53)

* content: add strcut and enum in the rust

* update

* update

docs/rust.md

@@ -143,25 +143,30 @@ foo!(3);
 
 ### 结构体
 
+结构体是一个使用关键字 `struct` 定义的标称型(nominal)结构体类型
+
 ```rust
 struct Point { x: i32, y: i32 }
 let p = Point { x: 10, y: 11 };
 let px: i32 = p.x;
 ```
 
-结构体是一个使用关键字 `struct` 定义的标称型(nominal)结构体类型
+#### 元祖结构体
-
-### 枚举
 
 ```rust
-enum Foo {
+struct Color (i32, i32, i32);
-  Bar,       // 0
+let black = Color(0,0,0);
-  Baz = 123, // 123
+```
-  Quux,      // 124
-}
 
-let baz_discriminant = Foo::Baz as u32;
+#### 单元结构体
-assert_eq!(baz_discriminant, 123);
+
+不关心该类型的内容, 只关心它的行为。
+
+```rust
+struct Solution;
+impl Solution{
+    // ...
+}
 ```
 
 ### 语句与表达式
@@ -246,6 +251,9 @@ println!("社区的名称是 {community_name}，它有 {no_of_members} 个成员
 查看: [字符串](#rust-字符串)
 
 ### 数组
+<!--rehype:wrap-class=row-span-2-->
+
+这里介绍的是固定长度的数组。rust 中常用的是集合类型 vec 表示的[动态数组](#rust-动态数组)
 
 ```rust
 ┌─────┬─────┬─────┬─────┬─────┬─────┐
@@ -260,28 +268,8 @@ println!("社区的名称是 {community_name}，它有 {no_of_members} 个成员
 let array: [i64; 6] = [92,97,98,99,98,94];
 ```
 
-### 多维数组
-<!--rehype:wrap-class=row-span-2-->
-
-```rust
-     j0   j1   j2   j3   j4   j5
-   ┌────┬────┬────┬────┬────┬────┐
-i0 | 1  | 2  | 3  | 4  | 5  | 6  |
-   ├────┼────┼────┼────┼────┼────┤
-i1 | 6  | 5  | 4  | 3  | 2  | 1  |
-   └────┴────┴────┴────┴────┴────┘
-```
-
 ----
 
-```rust
-let array: [[i64; 6] ;2] = [
-            [1,2,3,4,5,6],
-            [6,5,4,3,2,1]];
-```
-
-### 可变数组
-
 ```rust
 let mut array: [i32 ; 3] = [2,6,10];
 array[1] = 4;
@@ -299,14 +287,6 @@ let mut slices: &[i64] = &array[0..3]
 println!("切片的元素是：{slices:?}");
 ```
 
-### 向量
-
-```rust
-let some_vector = vec![1,2,3,4,5]; 
-```
-
-使用 `vec!` 宏声明向量
-
 ### 元组
 
 ```rust
@@ -397,8 +377,68 @@ println!("{:?}", str4);
 Rust 动态数组
 -----------
 
+### 创建动态数组
+
+```rust
+let v: Vec<i32> = Vec::new();
+// 使用宏
+let v1 = vec![1, 2, 3];
+```
+
+### 读取元素
+
+```rust
+let v = vec![1, 2, 3, 4, 5];
+
+let element = &v[100];
+// panic，越界
+let element2 = v.get(100);
+println!("{:?}", element2);
+//None
+```
+
+### 遍历数组
+
+1. 只读取数组中的元素
+
+   ```rust
+   let v = vec![1, 2, 3];
+   for i in &v {
+       println!("{}", i);
+   }
+   ```
+
+2. 遍历的同时修改数组中的元素
+
+   ```rust
+   let mut v = vec![1, 2, 3];
+   for i in &mut v {
+       *i += 10
+   }
+   ```
+
+### 多维数组
+
+```rust
+     j0   j1   j2   j3   j4   j5
+   ┌────┬────┬────┬────┬────┬────┐
+i0 | 1  | 2  | 3  | 4  | 5  | 6  |
+   ├────┼────┼────┼────┼────┼────┤
+i1 | 6  | 5  | 4  | 3  | 2  | 1  |
+   └────┴────┴────┴────┴────┴────┘
+```
+
+----
+
+```rust
+let arr = vec![
+    vec![1, 2, 3, 4, 5, 6],
+    vec![6, 5, 4, 3, 2, 1]
+];
+```
+
 ### 常用方法
-<!--rehype:wrap-class=col-span-2 row-span-2-->
+<!--rehype:wrap-class=col-span-2-->
 
 -|:-
 -|:-
@@ -415,43 +455,84 @@ Rust 动态数组
 `drain(range)`            | 删除 `vec` 中指定范围的元素,同时返回一个迭代该范围所有元素的迭代器
 `split_off(index)`        | 切分 `vec`，索引左边的元素保留在原 `vec` 中(含索引)，索引右边的元素(不含索引)在返回的 `vec` 中
 
-### 创建动态数组
+枚举
+--------
+
+### 在结构体中使用枚举
 
 ```rust
-let v: Vec<i32> = Vec::new();
+enum IpAddrKind {
-// 使用宏
+  V4,
-let v1 = vec![1, 2, 3];
+  V6,
-```
+}
+struct IpAddr {
+  kind: IpAddrKind,
+  address: String,
+}
 
-### 遍历数组
+fn main(){
-
+    let ip = IpAddr{
-只读取数组中的元素
+        kind: IpAddrKind::V4,
-
+        address: String::from("127.0.0.1")
-```rust
+    };
-let v = vec![1, 2, 3];
-for i in &v {
-  println!("{}", i);
 }
 ```
 
-遍历的同时修改数组中的元素
+### 枚举的变体
 
 ```rust
-let mut v = vec![1, 2, 3];
+enum IpAddrKind {
-for i in &mut v {
+  V4(u8, u8, u8, u8),
-  *i += 10
+  V6(String),
+}
+
+fn main() {
+  let home = IpAddrKind::V4(127, 0, 0, 1);
+  let loopback = IpAddrKind::V6(String::from("::1"));
 }
 ```
 
-### 读取元素
+----
 
 ```rust
-let v = vec![1, 2, 3, 4, 5];
+enum Message{
-let element = &v[100];
+  Quit,
-// panic，越界
+  Move {x:i32, y:i32},
-let element2 = v.get(100);
+  Write(String),
-println!("{:?}", element2);
+  ChangeColor(i32, i32, i32),
-//None
+}
+fn main(){
+  let q = Message::Quit;
+  let m = Message::Move {x:10, y:20};
+  let w = Message:: Write(String::from("hello"));
+  let c = Message::ChangeColor(10, 20, 30);
+}
+```
+
+### 模式匹配结构体
+
+```rust
+#[derive(Debug)]
+enum Grade {
+    A,
+    B,
+    C,
+}
+enum Subject {
+    Math(Grade),
+    English(Grade),
+}
+
+fn subject_grade(sub: Subject) {
+  match sub {
+    Subject::Math(grade) => println!("The Math is {:?}", grade),
+    Subject::English(grade) => println!("The Math is {:?}", grade),
+  }
+}
+
+fn main() {
+    subject_grade(Subject::Math(Grade::A));
+}
 ```
 
 Rust 运算符
@@ -528,7 +609,7 @@ let left_shift = h << 4;  // => 32
 示例 | 意义
 :- | :-
 `c && d` | 两者都是真的_(AND)_
-`c \|\| d` | 要么是真的 _(OR)_
+`c || d` | 要么是真的_(OR)_
 `!c`     | `c` 为假 _(NOT)_
 
 ----
@@ -803,7 +884,6 @@ match grade {
     _ => println!("Come on"),
 }
 ```
-<!--rehype:className=wrap-text -->
 
 ----
 
@@ -819,7 +899,6 @@ fn main(){
     println!("{:?}", p);
 }
 ```
-<!--rehype:className=wrap-text -->
 
 ----
 
@@ -844,7 +923,6 @@ match x {
     _ => println!("No match"),
 }// y = 2
 ```
-<!--rehype:className=wrap-text -->
 
 Rust 函数
 --------
@@ -860,7 +938,6 @@ fn print_message(){
 ```
 
 ### 参数值
-<!--rehype:wrap-class=row-span-2-->
 
 rust 需要为函数的参数标明确定的类型
 
@@ -876,7 +953,6 @@ fn main(){
 ```
 
 ### 返回值
-<!--rehype:wrap-class=row-span-2-->
 
 如果不指定返回值，rust 默认返回 `()` 类型
 
@@ -885,7 +961,9 @@ fn main(){
 fn main(){}
 ```
 
-使用 `->` 指定返回值，如果**表达式**在最后一行，无需使用 `return`
+----
+
+使用 `->` 指定返回值，如果**表达式**在最后一行，无需使用 return
 
 ```rust
 fn add(a:i32, b:i32) -> i32 {