Rust

const MAX_POINTS: u32 = 100_000;            // 一般，常量名全为大写，且使用下划线分开

const fn get_value1() -> u32 {
    1
}

fn get_value2() -> u32 {
    2
}

const X0: u32 = 0;                 // 使用 literal 初始化 const 常量
const X1: u32 = get_value1();      // 使用另一个 const 函数初始化 const 常量
// const X2: u32 = get_value2();   // 注：不能使用非 const 函数初始化 const 常量

fn main() {
    println!("X0: {}", X0);
    println!("X1: {}", X1);
}

const fn get_value1() -> u32 {
    1
}

static X0: u32 = 0;                 // 使用 literal 初始化 static 常量
static mut X1: u32 = get_value1();  // 使用另一个 const 函数初始化 static 常量

fn main() {
    println!("X0: {}", X0);

    unsafe {
        println!("X1: {}", X1);     // 访问 static mut 变量，需要使用 unsafe 包围
    }
}

let x: i32;
// x = 5;                              // 把这行最前面的注释打开，下一行就不报错了
println!("The value of x is: {}", x);  // 前面只声明了 x ，但没有给它赋值，直接使用 x 会报错

fn main() {
    let x: i32 = 17;
    {
        let y: i32 = 3;   // y 只在当前块中有效
        println!("The value of x is {} and value of y is {}", x, y);
    }
    println!("The value of x is {} and value of y is {}", x, y); // 编译出错，y 已经无效了
}

fn main() {
    let x: i32 = 8;
    {
        println!("{}", x); // Prints "8"
        let x = 12;        // 块里新定义了变量 x ，外层块的 x 被 shadowed
        println!("{}", x); // Prints "12"
    } // 这个块结束后，外层的 x 重新有效
    println!("{}", x); // Prints "8"
    let x= 42;         // 相当于重新定义了变量 x，第 2 行定义的 x 不再有效
    println!("{}", x); // Prints "42"
}

let spaces = "   ";          // spaces 是字符串类型
let spaces = spaces.len();   // 前一个 spaces 变量被 shadowed，等号左边的新变量 spaces 是整形

let mut spaces = "   ";
spaces = spaces.len();       // 编译出错，不能改变 spaces 的类型

pub struct Person {
    //! 这种风格的注释是 Inner doc，表示对它的外围环境（即 Person）的注释

    /// 这种风格的注释是 Outer doc，表示对它平级的下一行（即 name）的注释
    name: String,
}

/// A human being is represented here
pub struct Person {
    /// A person must have a name, no matter how much Juliet may hate it
    name: String,
}

impl Person {
    /// Returns a person with the name given them
    ///
    /// # Arguments
    ///
    /// * `name` - A string slice that holds the name of the person
    ///
    /// # Examples
    ///
    /// ```
    /// // You can have rust code between fences inside the comments
    /// // If you pass --test to `rustdoc`, it will even test it for you!
    /// use doc::Person;
    /// let person = Person::new("name");
    /// ```
    pub fn new(name: &str) -> Person {
        Person {
            name: name.to_string(),
        }
    }

    /// Gives a friendly hello!
    ///
    /// Says "Hello, [name]" to the `Person` it is called on.
    pub fn hello(& self) {
        println!("Hello, {}!", self.name);
    }
}

fn main() {
    let john = Person::new("John");

    john.hello();
}

let x: i32 = 10;

let y = x as i64;        // 从 i32 转换到 i64

1 + 3            // 这是表达式，会返回 4
fun1(1)          // 函数调用也是表达式
{                // {}块也是表达式，它返回块内最后一个表达式
    let x = 3;
    x + 1        // 这是块内的最后一个表达式（表达式后面不能加分号）
}

// 如果表达式后面增加分号，会变为语句
1 + 3;           // 这是语句

fn main() {
    let x = 5;

    let y = {
        let x = 3;
        x + 1        // {}块内最后一个表达式
    };

    println!("The value of y is: {}", y); // y 为 4
}

// 下面函数会返回 7
fn fun1() -> i32 {
    println!("this is fun1"); // 这是语句
    3 + 4                     // 最后一个表达式（没有加分号），函数默认返回函数体内最后一个表达式的值
                              // 相当于 return 3 + 4
                              //   写为 return 3 + 4; 也行（有分号）
}

fn fun1() -> i32 {
    println!("this is fun1");
    3 + 4;                    // 编译会出错。去掉分号，或者显式增加return语句即可通过编译
}

// 这个函数返回 5
fn five() -> i32 {
    5                 // 为上合法函数，函数默认返回函数体内最后一个表达式的值
}

fn main() {
    let x = 5;

    if x == 5 {
        println!("x is five!");
    } else if x == 6 {
        println!("x is six!");
    } else {
        println!("x is not five or six :(");
    }
}

let x = 5;
let y = if x == 5 { 10 } else { 15 };

fn main() {
    let number = 13;

    println!("Tell me about {}", number);
    match number {
        // Match a single value
        1 => println!("One!"),
        // Match several values
        2 | 3 | 5 | 7 | 11 => println!("This is a prime"),
        // Match an inclusive range
        13..=19 => println!("A teen"),
        // Handle the rest of cases
        _ => println!("Ain't special"),
    }
}

let s = "hello";         // hello 在可执行程序的text段中

{
    let mut s = String::from("hello");

    s.push_str(", world!"); // push_str() appends a literal to a String

    println!("{}", s);      // This will print `hello, world!`
} // 离开了作用域，s 不再有效，其 drop 方法会被调用

let mut x = 5;
let mut y = x;

let s1 = String::from("hello");
let s2 = s1;

let s1 = String::from("hello");
let s2 = s1;

println!("{}, world!", s1);     // 会报错，s1 不再有效，不能再访问 s1 了，"hello" 的 owner 从 s1 移到了 s2

let s1 = String::from("hello");
let s2 = s1.clone();

println!("s1 = {}, s2 = {}", s1, s2);

let x = 5;                        // x 是 i32 类型，直接保存在栈上
let y = x;                        // 会在栈上复制 x

println!("x = {}, y = {}", x, y); // 前面尽管把 x 赋值给了 y，但我们还可以访问 x

fn main() {
    // 下面测试一下Tuple 和数组如果其元素类型都是“整数/浮点数/布尔类型/字符”时的情况
    let a = [1, 2, 3, 4, 5];   // a 是数组，元素属于“整数/浮点数/布尔类型/字符”
    let b = a;                 // 不会 move；a 在后面还可以访问
    println!("{:?}", a);       // 还可以访问 a
    println!("{:?}", b);

    let x: (i32, f64, u8) = (500, 6.4, 1);  // x 是 Tuple，元素属于“整数/浮点数/布尔类型/字符”
    let y = x;                              // 不会 move；x 在后面还可以访问
    println!("{:?}", x);                    // 还可以访问 x
    println!("{:?}", y);

    // 下面测试一下Tuple 和数组有元素类型不是“整数/浮点数/布尔类型/字符”时的情况
    let a1 = [String::from("hello"), String::from("world")]; // a1 是数组，但元素不属于“整数/浮点数/布尔类型/字符”
    let b1 = a1;                            // 会发生 move，转换 owner；a1 在后面不能再使用了
    // println!("{:?}", a1);                // 不能再访问 a1 了，这行会报错
    println!("{:?}", b1);

    let x1: (i32, f64, String) = (500, 6.4, String::from("hello"));  // x1 是 Tuple，但有元素不属于“整数/浮点数/布尔类型/字符”
    let y1 = x1;                                 // 会发生 move，转换 owner；x1 在后面不能再使用了
    // println!("{:?}", x1);                     // 不能再访问 x1 了，这行会报错
    println!("{:?}", y1);
}

fn main() {
    let s = String::from("hello");  // s comes into scope

    takes_ownership(s);             // s's value moves into the function...
                                    // ... and so is no longer valid here

    let x = 5;                      // x comes into scope

    makes_copy(x);                  // x would move into the function,
                                    // but i32 is Copy, so it’s okay to still
                                    // use x afterward

} // Here, x goes out of scope, then s. But because s's value was moved, nothing
  // special happens.

fn takes_ownership(some_string: String) { // some_string comes into scope
    println!("{}", some_string);
} // Here, some_string goes out of scope and `drop` is called. The backing
  // memory is freed.

fn makes_copy(some_integer: i32) { // some_integer comes into scope
    println!("{}", some_integer);
} // Here, some_integer goes out of scope. Nothing special happens.

fn main() {
    let s1 = gives_ownership();         // gives_ownership moves its return
                                        // value into s1

    let s2 = String::from("hello");     // s2 comes into scope

    let s3 = takes_and_gives_back(s2);  // s2 is moved into
                                        // takes_and_gives_back, which also
                                        // moves its return value into s3
} // Here, s3 goes out of scope and is dropped. s2 goes out of scope but was
  // moved, so nothing happens. s1 goes out of scope and is dropped.

fn gives_ownership() -> String {             // gives_ownership will move its
                                             // return value into the function
                                             // that calls it

    let some_string = String::from("hello"); // some_string comes into scope

    some_string                              // some_string is returned and
                                             // moves out to the calling
                                             // function
}

// takes_and_gives_back will take a String and return one
fn takes_and_gives_back(a_string: String) -> String { // a_string comes into
                                                      // scope

    a_string  // a_string is returned and moves out to the calling function
}

fn main() {
    let s1 = String::from("hello");

    let (s2, len) = calculate_length(s1);         // calculate_length 会拿走s1对字符串"hello"的ownership
                                                  // 如果后面还要使用字符串"hello"时，则我们可以让calculate_length再返回字符串
                                                  // 由于s1对"hello"没有ownership了，后面还使用"hello"时只能使用s2了

    println!("The length of '{}' is {}.", s2, len);
}

fn calculate_length(s: String) -> (String, usize) {  // 返回tuple
    let length = s.len(); // len() returns the length of a String

    (s, length)
}

fn main() {
    let s = String::from("hello");

    change(&s);
}

fn change(some_string: &String) {
    some_string.push_str(", world");   // 会报错！引用默认是只读的，不能在函数内修改字符串
}

fn main() {
    let mut s = String::from("hello");

    change(&mut s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

fn main() {
    let mut s = String::from("hello");

    let r1 = &mut s;                     // r1 是 s 的可修改引用
    let r2 = &mut s;                     // 编译失败

    println!("{}, {}", r1, r2);
}

let mut s = String::from("hello");

{
    let r1 = &mut s;

} // r1 goes out of scope here, so we can make a new reference with no problems.

let r2 = &mut s;

// 编译会出错
fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String {
    let s = String::from("hello");  // s is a new String

    &s                     // we return a reference to the String, s
} // Here, s goes out of scope, and is dropped. Its memory goes away.
  // Danger!

let s = String::from("hello world");

let world = &s[6..11];            // world 的类型为 &str

println!("{}", world);            // world

let sub_world: String = world.chars().skip(2).collect(); // 跳过前 2 个 chars
println!("{}", sub_world);        // rld

let sub_world: String = world.chars().take(4).collect(); // 只取 4 个 chars
println!("{}", sub_world)         // worl

fn first_word(s: &String) -> &str {         // 返回类型是字符串Slice
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s);

    s.clear();                              // 会报错，编译器发现后面会用到word

    println!("the first word is: {}", word);
}

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let email = String::from("someone@example.com");
    let username = String::from("someusername123");

    let user1 = User {
        email: email,       // 前面的 email 是字段名，后面的 email 是变量名
        username: username, // 前面的 username 是字段名，后面的 username 是变量名
        active: true,
        sign_in_count: 1,
    };

    println!("{}, {}, {}, {}", user1.email, user1.username,
             user1.active, user1.sign_in_count);
}

let user1 = User {
        email,               // 相当于 email: email,
        username,            // 相当于 username: username,
        active: true,
        sign_in_count: 1,
    };

let user2 = User {
    email: String::from("another@example.com"),
    username: String::from("anotherusername567"),
    active: user1.active,
    sign_in_count: user1.sign_in_count,
};

let user2 = User {
    email: String::from("another@example.com"),
    username: String::from("anotherusername567"),
    ..user1
};

struct Foo{
    a: i32,
    b: i32,
}

impl Foo {
    fn new() -> Self {    // 这个 Self 可以换为 Foo
        Self {            // 这个 Self 也可以换为 Foo
            a: 100,
            b: 100,
        }
    }
}

fn main() {
    assert_eq!(Foo::new().a, Foo{a: 100, b: 100 }.a);
    assert_eq!(Foo::new().b, Foo{a: 100, b: 100 }.b);
}

trait ConstantIdDefault {
    const ID: i32 = 1;                      // 这是 Associated Constants
}

struct Struct;
struct OtherStruct;

impl ConstantIdDefault for Struct {}

impl ConstantIdDefault for OtherStruct {
    const ID: i32 = 5;                      // 这是 Associated Constants
}

fn main() {
    assert_eq!(1, Struct::ID);
    assert_eq!(5, OtherStruct::ID);
}

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn square(size: u32) -> Rectangle {    // 第一个参数不是 self，它是关联函数
        Rectangle { width: size, height: size }
    }
}

impl Rectangle {
    fn area(&self) -> u32 {        // 第一个参数是 self，它是方法
        self.width * self.height
    }
}

fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };
    println!("The area of the rectangle is {} square pixels.", rect1.area());

    let sq = Rectangle::square(3);
    println!("The area of the rectangle is {} square pixels.", sq.area());
}

enum Option<T> {
    Some(T),
    None,
}

let some_number = Some(5);
let some_string = Some("a string");

let absent_number: Option<i32> = None;

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        None => None,
        Some(i) => Some(i + 1),
    }
}

let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);

let some_u8_value = 0u8;

match some_u8_value {        // u8 的可能值为 0-255
    1 => println!("one"),
    2 => println!("two"),
    3 => println!("three"),
    _ => (),                 // _ 这里表示除1,2,3外的其它情况，即 0, 4-255
}

mod deeply {
    pub mod nested {
        pub fn function() {
            println!("called `deeply::nested::function()`");
        }
        pub fn function1() {
            println!("called `deeply::nested::function1()`");
        }
        pub fn function2() {
            println!("called `deeply::nested::function2()`");
        }
    }
}

use deeply::nested::{
    function,        // 可以直接使用 function 来代替 deeply::nested::function了，更方便
    function1,       // 可以直接使用 function1 来代替 deeply::nested::function1 了，更方便
};

fn main() {
    // Easier access to `deeply::nested::function` and `deeply::nested::function1`
    function();
    function1();

    deeply::nested::function2();  // 这里不使用 use 也行，只是需要输入完整的 path
}

// Bind the `deeply::nested::function` path to `other_function`.
use deeply::nested::function as other_function;

fn function() {
    println!("called `function()`");
}

mod deeply {
    pub mod nested {
        pub fn function() {
            println!("called `deeply::nested::function()`");
        }
    }
}

fn main() {
    // Easier access to `deeply::nested::function`
    other_function();

    println!("Entering block");
    {
        // This is equivalent to `use deeply::nested::function as function`.
        // This `function()` will shadow the outer one.
        use deeply::nested::function;

        // `use` bindings have a local scope. In this case, the
        // shadowing of `function()` is only in this block.
        function();

        println!("Leaving block");
    }

    function();
}

fn function() {
    println!("called `function()`");
}

mod cool {
    pub fn function() {
        println!("called `cool::function()`");
    }
}

mod my {
    fn function() {
        println!("called `my::function()`");
    }

    mod cool {
        pub fn function() {
            println!("called `my::cool::function()`");
        }
    }

    pub fn indirect_call() {
        // Let's access all the functions named `function` from this scope!
        print!("called `my::indirect_call()`, that\n> ");

        // The `self` keyword refers to the current module scope - in this case `my`.
        // Calling `self::function()` and calling `function()` directly both give
        // the same result, because they refer to the same function.
        self::function();
        function();

        // We can also use `self` to access another module inside `my`:
        self::cool::function();

        // The `super` keyword refers to the parent scope (outside the `my` module).
        super::function();

        // This will bind to the `cool::function` in the *crate* scope.
        // In this case the crate scope is the outermost scope.
        {
            use crate::cool::function as root_function;
            root_function();
        }
    }
}

fn main() {
    my::indirect_call();
}

|-- my
|   `-- mod.rs
`-- split.rs

// This declaration will look for a file named `my.rs` or `my/mod.rs` and will
// insert its contents inside a module named `my` under this scope
mod my;

fn main() {
    my::function();
}

pub fn function() {
    println!("called `function()`");
}

use std::fs::File;

fn main() {
    let f = File::open("hello.txt");

    let f = match f {
        Ok(file) => file,
        Err(error) => {
            panic!("Problem opening the file: {:?}", error)
        },
    };
}

use std::fs::File;

fn main() {
    let f = File::open("hello.txt").unwrap();
}

use std::fs::File;

fn main() {
    let f = File::open("hello.txt").expect("Failed to open hello.txt");
}

use std::io;
use std::io::Read;
use std::fs::File;

fn read_username_from_file() -> Result<String, io::Error> {
    let f = File::open("hello.txt");

    let mut f = match f {
        Ok(file) => file,
        Err(e) => return Err(e),       // 有错就 return
    };

    let mut s = String::new();

    match f.read_to_string(&mut s) {
        Ok(_) => Ok(s),
        Err(e) => Err(e),              // 不用明确写 return，因是它是函数的最后一个表达式
    }
}

use std::io;
use std::io::Read;
use std::fs::File;

fn read_username_from_file() -> Result<String, io::Error> {
    let mut f = File::open("hello.txt")?;  // ? 表示如果出错，就返回错误
    let mut s = String::new();
    f.read_to_string(&mut s)?;             // ? 表示如果出错，就返回错误
    Ok(s)
}

use std::io;
use std::io::Read;
use std::fs::File;

fn read_username_from_file() -> Result<String, io::Error> {
    let mut s = String::new();

    File::open("hello.txt")?.read_to_string(&mut s)?;

    Ok(s)
}

use std::io;
use std::fs;

fn read_username_from_file() -> Result<String, io::Error> {
    fs::read_to_string("hello.txt")
}

fn notify(item: impl Summary + Display) {    // item 同时满足 Summary 和 Display

fn notify<T: Summary + Display>(item: T) {

fn some_function<T: Display + Clone, U: Clone + Debug>(t: T, u: U) -> i32 {

fn some_function<T, U>(t: T, u: U) -> i32           // 同上面代码
    where T: Display + Clone,
          U: Clone + Debug
{

let s: &'static str = "I have a static lifetime.";

use std::fmt::Debug;

fn print_it( input: impl Debug + 'static ) {                // input 使用了 'static Trait bound
    println!( "'static value passed in is: {:?}", input );
}

fn main() {
    // i is owned and contains no references, thus it's 'static:
    let i = 5;
    print_it(i);

    let s = "hello world".to_string();
    // print_it(&s);          // 这里会报错，因为 &s only has the lifetime defined by the scope of main()
    print_it(s);              // 这里不会报错，因为 s is owned。

    // oops, &i only has the lifetime defined by the scope of
    // main(), so it's not 'static:
    //print_it(&i);
}

let num = 5;
let add_num = |x: i32| x + num;         // 捕获环境中的变量 num

assert_eq!(10, add_num(5));

use std::ops::Deref;

struct MyBox<T>(T);             // 这是个 Tuple struct，仅有一个字段

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

impl<T> Deref for MyBox<T> {    // 通过实现 Deref trait 将某类型像引用一样处理
    type Target = T;            // 这是 Associated type

    fn deref(&self) -> &T {
        &self.0                 // 返回了 Tuple struct 中的首个字段的引用
    }
}

fn main() {
    let x = 5;
    let y = MyBox::new(x);

    assert_eq!(5, x);
    assert_eq!(5, *y);
}

struct CustomSmartPointer {
    data: String,
}

impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data `{}`!", self.data);
    }
}

fn main() {
    let c = CustomSmartPointer { data: String::from("some data") };
    println!("CustomSmartPointer created.");
    drop(c);                                      // 这是调用 std::mem::drop，会提早执行 c 的 drop 方法
    println!("CustomSmartPointer dropped before the end of main.");
}

use std::cell::{RefCell, Cell};
//use std::borrow::{Borrow, BorrowMut};

fn main() {
    #[derive(Debug, Default)]
    struct S { a: i32};

    let c = Cell::new(S { a: 100});
    // println!("{:?}", x.get());       // 这里会报错，S 没有实现 Copy trait，不能调用 get

    c.set(S { a: 200} );                // 设置新值 S { a: 200}，drop 旧值S { a: 100 }

    let old = c.replace(S { a: 300} );  // 设置新值S { a: 300}，返回旧值 S { a: 200 }
    println!("{:?}", old);              // 输出 S { a: 200 }

    let x = c.take();                   // 设置新值为“类型默认值”，返回旧值 S { a: 300 }
    println!("{:?}", x);                // 输出 S { a: 300 }

    let y = c.take();                   // 上一次 take 后，Cell 中的值已经变为了“类型默认值”，这里再 take 得到的是“类型默认值”
    println!("{:?}", y);                // 输出 S { a: 0 }

    let z = c.into_inner();             // Cell 被消耗掉（后面不再可访问），返回 Cell 中数据给调用者
    println!("{:?}", z);                // 输出 S { a: 0 }

    // println!("{:?}", x.take());      // 这里会报错，一旦调用过 into_inner 后，x 不再可访问了
}

pub fn borrow(&self) -> Ref<T>                 // 获得底层数据的中读引用
pub fn borrow_mut(&self) -> RefMut<T>          // 获得底层数据的可修改引用

use std::cell::{RefCell, Ref, RefMut};

fn main() {
    #[derive(Debug, Default)]
    struct S { a: i32};

    let c = RefCell::new(S { a: 100});

    {
        let x: Ref<S> = c.borrow();            // 调用 borrow()，Ref<S> 计算加 1
        println!("{:?}", *x);
        let y: Ref<S> = c.borrow();            // 调用 borrow()，Ref<S> 计算加 1
        println!("{:?}", y);
        // let z: RefMut<S> = c.borrow_mut();  // 运行时 panic，只读引用和可修改引用不能同时存在
    } // 超过了作用域，x，y 对应的计数都会减去

    let z: RefMut<S> = c.borrow_mut();         // 前面的借用都超过了作用域，这里不会报错
    println!("{:?}", z);
}

let x = 5;                     // 其实 x 在这里也是一种模式

let PATTERN = EXPRESSION;

let (x, y, z) = (1, 2, 3);     // x, y, z 分别为 1, 2, 3
let (x, _, z) = (1, 2, 3);     // _ 表示忽略模式中的值。x, z 分别为 1, 3
let (x, ..)   = (1, 2, 3);     // .. 表示忽略所剩部分的值。x 为 1

fn foo(x: i32) {
    // code goes here
}

fn main() {}

fn print_coordinates(&(x, y): &(i32, i32)) {
    println!("Current location: ({}, {})", x, y);
}

fn main() {
    let point = (3, 5);
    print_coordinates(&point);       // Current location: (3, 5)
}

fn main() {
    let v = vec!['a', 'b', 'c'];

    for (index, value) in v.iter().enumerate() {     // (index, value) 是模式
        println!("{} is at index {}", value, index);
    }
}

fn main() {
    for i in -2..5 {
        match i {
            -1 => println!("It's minus one"),
            1 => println!("It's a one"),
            2|4 => println!("It's either a two or a four"),
            _ => println!("Matched none of the arms"),
        }
    }
}

let x = 4;                                                // 匹配的值绑定到了变量 x
let mut y = 5;                                            // 匹配的值绑定到了变量 y


let x = 2;
match x {
    e @ 1 ..= 5 => println!("got a range element {}", e), // 匹配的值绑定到了变量 e 中
    _ => println!("anything"),
}

fn main() {
    let x = 20;
    let (a, _) = (10, x);   // 忽略 x
    assert_eq!(a, 10);
}

fn main() {
    let words = vec!["a", "b", "c", "d"];
    let slice = &words[..];
    match slice {
        [] => println!("slice is empty"),
        [one] => println!("single element {}", one),
        [head, "b", tail @ ..] => println!("head={}, second=b, tail={:?}", head, tail),  // 输出 head=a, second=b, tail=["c", "d"]
        rest => println!("{:?}", rest),
    }

    let tuple = (1, 2, 3, 4, 5);
    match tuple {
        (1, .., y, z) => println!("y={}, z={}", y, z), // 输出 y=4, z=5
        (.., 5) => println!("tail must be 5"),
        (..) => println!("matches everything else"),
    }
}

fn main() {
    let ph = 10;
    let result = match ph {
        0..=6 => "acid",
        7 => "neutral",
        8..=14 => "base",
        _ => unreachable!(),
    };
    println!("{}", result);

    let c = 'f';
    let valid_variable = match c {
        'a'..='z' => true,
        'A'..='Z' => true,
        'α'..='ω' => true,
        _ => false,
    };
    println!("{}", valid_variable)
}

fn main() {
    let reference: &i32 = &4;

    match reference {
        &val => println!("Got a value via destructuring: {:?}", val),   // val 的类型是 i32，如果省略 val 前的 &，则 val 类型是 &i32
    }

    // To avoid the `&`, you can dereference before matching.
    match *reference {
        val => println!("Got a value via dereferencing: {:?}", val),    // val 的类型是 i32
    }
}

fn main() {
    struct Point {
        x: u32,
        y: u32,
    }
    let s = Point {x: 10, y: 20};

    match s {
        Point {x: 10, y: 20} => (),    // 使用“字段名字”
        Point {y: 10, x: 20} => (),    // order doesn't matter
        Point {x: 10, ..} => (),
        Point {..} => (),
    }

    struct PointTuple (
        u32,
        u32,
    );
    let t = PointTuple(10, 20);

    match t {
        PointTuple {0: 10, 1: 20} => (),   // Tuple struct 可以使用“字段下标”
        PointTuple {1: 10, 0: 20} => (),   // order doesn't matter
        PointTuple {0: 10, ..} => (),
        PointTuple {..} => (),
    }
}

fn main() {
    struct Point {
        x: u32,
        y: u32,
    }
    let s = Point {x: 10, y: 20};

    let Point{x: v1, y: v2} = s;   // 会把 s 解构，v1 会绑定 10，v2 会绑定 20
    println!("v1 = {}, v2 = {}", v1, v2); // v1 = 10, v2 = 20

    let Point{x, y} = s;              // 同上面，只是绑定的变量和字段同名，这时可简写
    println!("x = {}, y = {}", x, y); // x = 10, y = 20
}

fn main() {
    struct Point {
        x: u32,
        y: u32,
    }
    let s = Point { x: 10, y: 20 };

    match s {
        Point {x,  y: 20 } => {      // Point { x: x, y: 20 } 的缩写
        //     ^        ^
        //     |        |
        // 用于绑定   用于匹配
            println!("x={}", x)
        }
        Point { .. } => (),
    }
}

fn main() {
    let a = (1, 3, String::from("hello rust"));
    if let (x, y @ 2...5, z) = a {
        println!("{:?}, {:?}, {:?}", x, y, z);
    }
}

fn main() {
    let int_reference = &3;
    match int_reference {
        &(0..=5) => (),         // &0..=5 有歧义，无法通过编译，需要增加小括号
        _ => (),
    }
}

fn main() {
    let arr = [1, 2, 3];
    match arr {
        [1, _, _] => "starts with one",
        [a, b, c] => "starts with something else",
    };
}

pub trait Iterator {
    type Item;                                    // Item 是关联类型（占位符类型）

    fn next(&mut self) -> Option<Self::Item>;     // 返回 Option<Self::Item>
}

// 下面是 Iterator 的假想定义
pub trait Iterator<T> {                           // 泛型 T
    fn next(&mut self) -> Option<T>;              // 返回 Option<T>
}

use std::fmt::Debug;

pub trait Iterator {
    type Item:Debug;                              // Item:Debug 表示关联类型 Item 需要实现 Debug

    fn next(&mut self) -> Option<Self::Item>;
}

pub trait Container<XXX=String> {                 // XXX=String 就是默认泛型类型参数
    fn get_data(&self) -> XXX;
}

struct A {
    data: i32,
}

impl Container<i32> for A {
    fn get_data(&self) -> i32 {
        println!("A data is {}", self.data);
        self.data
    }
}

struct B {
    data: String,
}

impl Container for B {                            // 相当于 Container<String>，但 String 这里可省略
    fn get_data(&self) -> String {
        println!("B data is {}", self.data);
        self.data.clone()
    }
}

fn main() {
    let a = A{data: 100};
    let b = B{data: String::from("Hello")};
    assert_eq!(100, a.get_data());
    assert_eq!("Hello", b.get_data());
}

fn main() {
    let vec = vec!['a', 'b', 'c'];
    for i in 0..vec.len() {
        println!("{}", vec[i]);
    }
}

fn main() {
    let vec = vec!['a', 'b', 'c'];
    #[allow(clippy::needless_range_loop)] // disable clippy lint
    for i in 0..vec.len() {
        println!("{}", vec[i]);
    }
}