Rust是基于表达式的编程语言，有且仅有两种语句 (statement)：

    1. 声明语句 (declaration statement)，比如进行变量绑定的let语句。
    2. 表达式语句 (expression statement)，它通过在末尾加上分号;来将表达式变成语句，
      丢弃该表达式的值，一律返回元类型()。

    表示式总是返回一个值，但是语句不返回值或者返回()，所以以下代码会报错：

    1. let y = (let x = 5);
    3. let z: i32 = if x == 5 { 10; } else { 15; };

    值得注意的是，在Rust中赋值 (如x = 5) 也是一个表达式，返回元类型值()。

    1. for var in expression {
    2.     code
    3. }

    其中expression是一个迭代器 (iterator)，具体的例子为0..10 (不包含最后一个值)，
    或者[0, 1, 2].iter()。

    Rust中的while循环与C语言中的类似。对于无限循环，Rust有一个专用的关键字loop。
    如果需要提前退出循环，可以使用关键字break或者continue，
    还允许在循环的开头设定标签 (同样适用于for循环)：

    Rust中的match表达式非常强大，首先看一个例子：

    1. let day = 5;
    4.   0 | 6 => println!("weekend"),
    5.   1 ... 5 => println!("weekday"),
    6. }
    1. let x = 1;
    3. match x {
    4.     e @ 1 ... 5 => println!("got a range element {}", e),
    5.     _ => println!("anything"),
    6. }

    使用ref关键字来得到一个引用：

    再看一个使用match表达式来解构元组的例子：

    1. let pair = (0, -2);
    3. match pair {
    4.     (0, y) => println!("x is `0` and `y` is `{:?}`", y),
    5.     (x, 0) => println!("`x` is `{:?}` and y is `0`", x),
    6.     _ => println!("It doesn't matter what they are"),
    7. }

    的这种解构同样适用于结构体或者枚举。如果有必要，
    还可以使用..来忽略域或者数据：

    1. struct Point {
    2.     x: i32,
    3.     y: i32,
    5. let origin = Point { x: 0, y: 0 };
    7. match origin {
    8.     Point { x, .. } => println!("x is {}", x),
    9. }
    11. enum OptionalInt {
    12.     Value(i32),
    13.     Missing,
    14. }
    16. let x = OptionalInt::Value(5);
    18. match x {
    19.     OptionalInt::Value(i) if i > 5 => println!("Got an int bigger than five!"),
    20.     OptionalInt::Value(..) => println!("Got an int!"),
    21. }