rewrite: add 04 chapter (#203)

* fix #160

* rewrite 04 chapter: add 04-00-rust-travel

* fix #163

* update 12-01

* add 04-01-primitive-type && update 04-00

* add 04-01-primitive-type && update 04-00

* add 04-01-primitive-type && update 04-00

* update readme

* update readme

* add 04-02-primitive-type

* add 04-03-struct-enum

* rewrite: add 04 chapter

Author: Naupio Z.Y. Huang

04-quickstart-rewrite-WIP/04-03-string-vector.md

@@ -0,0 +1 @@
+04-03-字符串与向量

04-quickstart-rewrite-WIP/04-04-struct-enum.md

@@ -0,0 +1,102 @@
+# 结构体与枚举
+
+## 结构体
+
+结构体 (struct) 是一种记录类型，所包含的每个域 (field) 都有一个名称。
+每个结构体也都有一个名称，通常以大写字母开头，使用驼峰命名法。
+元组结构体 (tuple struct) 是由元组和结构体混合构成，元组结构体有名称，
+但是它的域没有。当元组结构体只有一个域时，称为新类型 (newtype)。
+没有任何域的结构体，称为类单元结构体 (unit-like struct)。
+结构体中的值默认是不可变的，需要使用`mut`使其可变。
+
+```rust
+// structs
+struct Point {
+  x: i32,
+  y: i32,
+}
+let mut point = Point { x: 0, y: 0 };
+
+// tuple structs
+struct Color(u8, u8, u8);
+let android_green = Color(0xa4, 0xc6, 0x39);
+let (red, green, blue) = android_green;
+
+// A tuple struct’s constructors can be used as functions.
+struct Digit(i32);
+let v = vec![0, 1, 2];
+let d: Vec<Digit> = v.into_iter().map(Digit).collect();
+
+// newtype: a tuple struct with only one element
+struct Inches(i32);
+let length = Inches(10);
+let Inches(integer_length) = length;
+
+// unit-like structs
+struct Null;
+let empty = Null;
+```
+
+一个包含`..`的`struct`可以用来从其它结构体拷贝一些值或者在解构时忽略一些域：
+
+```rust
+#[derive(Default)]
+struct Point3d {
+    x: i32,
+    y: i32,
+    z: i32,
+}
+
+let origin = Point3d::default();
+let point = Point3d { y: 1, ..origin };
+let Point3d { x: x0, y: y0, .. } = point;
+```
+
+需要注意，Rust在语言级别不支持域可变性 (field mutability)，所以不能这么写：
+
+```rust
+struct Point {
+    mut x: i32,
+    y: i32,
+}
+```
+这是因为可变性是绑定的一个属性，而不是结构体自身的。可以使用`Cell<T>`来模拟：
+
+```rust
+use std::cell::Cell;
+
+struct Point {
+    x: i32,
+    y: Cell<i32>,
+}
+
+let mut point = Point { x: 5, y: Cell::new(6) };
+
+point.y.set(7);
+```
+
+此外，结构体的域默认是私有的，可以使用`pub`关键字将其设置成公开。
+
+## 枚举
+
+Rust有一个集合类型，称为枚举 (enum)，对于一个指定的名称有一组可替代的值，
+其中子数据结构可以存储也可以不存储数据，需要使用`::`语法来获得每个元素的名称。
+
+```rust
+// enums
+enum Message {
+    Quit,
+    ChangeColor(i32, i32, i32),
+    Move { x: i32, y: i32 },
+    Write(String),
+}
+
+let x: Message = Message::Move { x: 3, y: 4 };
+```
+
+与结构体一样，枚举中的元素默认不能使用关系运算符进行比较 (如`==`, `!=`, `>=`)，
+也不支持像`+`和`*`这样的双目运算符，需要自己实现，或者使用`match`进行匹配。
+
+枚举默认也是私有的，如果使用`pub`使其变为公有，则它的元素也都是默认公有的。
+这一点是与结构体不同的：即使结构体是公有的，它的域仍然是默认私有的。
+此外，枚举和结构体也可以是递归的 (recursive)。

04-quickstart-rewrite-WIP/04-05-control-stream.md

@@ -0,0 +1,172 @@
+# 操作流
+
+## If
+
+If是分支 (branch) 的一种特殊形式，也可以使用`else`和`else if`。
+与C语言不同的是，逻辑条件不需要用小括号括起来，但是条件后面必须跟一个代码块。
+Rust中的`if`是一个表达式 (expression)，可以赋给一个变量：
+
+```rust
+let x = 5;
+
+let y = if x == 5 { 10 } else { 15 };
+```
+
+Rust是基于表达式的编程语言，有且仅有两种语句 (statement)：
+
+1. **声明语句** (declaration statement)，比如进行变量绑定的`let`语句。
+2. **表达式语句** (expression statement)，它通过在末尾加上分号`;`来将表达式变成语句，
+丢弃该表达式的值，一律返回元类型`()`。
+
+表示式总是返回一个值，但是语句不返回值或者返回`()`，所以以下代码会报错：
+
+```rust
+let y = (let x = 5);
+
+let z: i32 = if x == 5 { 10; } else { 15; };
+```
+
+值得注意的是，在Rust中赋值 (如`x = 5`) 也是一个表达式，返回元类型值`()`。
+
+## For
+
+Rust中的`for`循环与C语言的风格非常不同，抽象结构如下：
+
+```rust
+for var in expression {
+    code
+}
+```
+其中`expression`是一个迭代器 (iterator)，具体的例子为`0..10` (不包含最后一个值)，
+或者`[0, 1, 2].iter()`。
+
+## While
+
+Rust中的`while`循环与C语言中的类似。对于无限循环，Rust有一个专用的关键字`loop`。
+如果需要提前退出循环，可以使用关键字`break`或者`continue`，
+还允许在循环的开头设定标签 (同样适用于`for`循环)：
+
+```rust
+'outer: loop {
+   println!("Entered the outer loop");
+
+   'inner: loop {
+       println!("Entered the inner loop");
+       break 'outer;
+   }
+
+   println!("This point will never be reached");
+}
+
+println!("Exited the outer loop");
+```
+
+## Match
+
+Rust中的`match`表达式非常强大，首先看一个例子：
+
+```rust
+let day = 5;
+
+match day {
+  0 | 6 => println!("weekend"),
+  1 ... 5 => println!("weekday"),
+  _ => println!("invalid"),
+}
+```
+其中`|`用于匹配多个值，`...`匹配一个范围 (包含最后一个值)，并且`_`在这里是必须的，
+因为`match`强制进行穷尽性检查 (exhaustiveness checking)，必须覆盖所有的可能值。
+如果需要得到`|`或者`...`匹配到的值，可以使用`@`绑定变量：
+
+```rust
+let x = 1;
+
+match x {
+    e @ 1 ... 5 => println!("got a range element {}", e),
+    _ => println!("anything"),
+}
+```
+
+使用`ref`关键字来得到一个引用：
+
+```rust
+let x = 5;
+let mut y = 5;
+
+match x {
+    // the `r` inside the match has the type `&i32`
+    ref r => println!("Got a reference to {}", r),
+}
+
+match y {
+    // the `mr` inside the match has the type `&i32` and is mutable
+    ref mut mr => println!("Got a mutable reference to {}", mr),
+}
+```
+
+再看一个使用`match`表达式来解构元组的例子：
+
+```rust
+let pair = (0, -2);
+
+match pair {
+    (0, y) => println!("x is `0` and `y` is `{:?}`", y),
+    (x, 0) => println!("`x` is `{:?}` and y is `0`", x),
+    _ => println!("It doesn't matter what they are"),
+}
+```
+
+`match`的这种解构同样适用于结构体或者枚举。如果有必要，
+还可以使用`..`来忽略域或者数据：
+
+```rust
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+let origin = Point { x: 0, y: 0 };
+
+match origin {
+    Point { x, .. } => println!("x is {}", x),
+}
+
+enum OptionalInt {
+    Value(i32),
+    Missing,
+}
+
+let x = OptionalInt::Value(5);
+
+match x {
+    OptionalInt::Value(i) if i > 5 => println!("Got an int bigger than five!"),
+    OptionalInt::Value(..) => println!("Got an int!"),
+    OptionalInt::Missing => println!("No such luck."),
+}
+```
+
+此外，Rust还引入了`if let`和`while let`进行模式匹配：
+
+```rust
+let number = Some(7);
+let mut optional = Some(0);
+
+// If `let` destructures `number` into `Some(i)`, evaluate the block.
+if let Some(i) = number {
+    println!("Matched {:?}!", i);
+} else {
+    println!("Didn't match a number!");
+}
+
+// While `let` destructures `optional` into `Some(i)`, evaluate the block.
+while let Some(i) = optional {
+    if i > 9 {
+        println!("Greater than 9, quit!");
+        optional = None;
+    } else {
+        println!("`i` is `{:?}`. Try again.", i);
+        optional = Some(i + 1);
+    }
+}
+```
+