Rust语言

curl https://sh.rustup.rs -sSf | sh

{
	"version": "0.2.0",
	"configurations": [
		{
			"name": "test",
			"type": "lldb",
			"request": "launch",
			"cargo": {
				// "args": ["test", "--no-run", "--lib"], // Cargo command line to build the debug target
				"args": ["build"], // is another possibility
			}
		}
	]
}

mkdir hello_world
cd hello_world

fn main() {
    println!("Hello, world!");
}

rustc main.rs
./main

cargo --version

cargo new hello_cargo

[package]
name = "hello_cargo"
version = "0.1.0"
authors = ["rectcircle <[email protected]>"]
edition = "2018"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

cargo new guessing_game

[package]
name = "guessing_game"
version = "0.1.0"
authors = ["rectcircle <[email protected]>"]
edition = "2018"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
rand = "0.3.14"

use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1, 101);

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

        io::stdin().read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("You guessed: {}", guess);

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

cargo new variables

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
    x = 6; // 此行将编译报错，因为修改了不可便变量
    println!("The value of x is: {}", x);
}

    let mut x = 5;
    println!("The value of x is: {}", x);
    x = 6;
    println!("The value of x is: {}", x);

    let x = 5;

    let x = x + 1;

    let x = x * 2;

    println!("The value of x is: {}", x);

    let spaces = "   ";
    let spaces = spaces.len();
    println!("The value of spaces is: {}", spaces);

    // let mut spaces1 = "   ";
    // spaces1 = spaces1.len(); // 编译报错

fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

fn main() {
    // addition
    let sum = 5 + 10;

    // subtraction
    let difference = 95.5 - 4.3;

    // multiplication
    let product = 4 * 30;

    // division
    let quotient = 56.7 / 32.2;

    // remainder
    let remainder = 43 % 5;
}

fn main() {
    let t = true;

    let f: bool = false; // with explicit type annotation
}

fn main() {
    let c = 'z';
    let z = 'ℤ';
    let heart_eyed_cat = '😻';
}

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

fn main() {
    let a: [i32; 5] = [1, 2, 3, 4, 5];
    let b = [3; 5]; // 长度为5，元素全部都是3的数组


    let first = a[0];
    let second = a[1];
}

fn main() {
    another_function(5);
}

fn another_function(x: i32) {
    println!("The value of x is: {}", x);
}

pub const fn cube(num: usize) -> usize {
    num * num * num
}

pub static STATIC_VAR: usize = cube(3usize);

// hello, world

fn main() {
    let number = 3;

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {}", result);

    'outer: loop {
        while true {
            break 'outer;
        }
    }

    let mut number = 3;

    while number != 0 {
        println!("{}!", number);

        number -= 1;
    }

    println!("LIFTOFF!!!");

    let mut x = vec![1, 2, 3];

    while let Some(y) = x.pop() {
        println!("y = {}", y);
    }

    while let _ = 5 {
        println!("Irrefutable patterns are always true");
        break;
    }

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a.iter() {
        println!("the value is: {}", element);
    }

    for number in (1..4).rev() {
        println!("{}!", number);
    }
    println!("LIFTOFF!!!");
}

[profile.release]
panic = 'abort'

fn main() {
    panic!("crash and burn");
}

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/error_handle`
thread 'main' panicked at 'crash and burn', src/main.rs:2:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

    let v = vec![1, 2, 3];
    v[99];

$ cargo run
   Compiling error_handle v0.1.0 (/Users/sunben/Workspace/learn/rust/error_handle)
    Finished dev [unoptimized + debuginfo] target(s) in 0.64s
     Running `target/debug/error_handle`
thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', /rustc/4560ea788cb760f0a34127156c78e2552949f734/src/libcore/slice/mod.rs:2717:10
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

$ RUST_BACKTRACE=1 cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.01s
     Running `target/debug/error_handle`
thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', /rustc/4560ea788cb760f0a34127156c78e2552949f734/src/libcore/slice/mod.rs:2717:10
stack backtrace:
   0: backtrace::backtrace::libunwind::trace
             at /Users/runner/.cargo/registry/src/github.com-1ecc6299db9ec823/backtrace-0.3.37/src/backtrace/libunwind.rs:88
  省略...
  26: std::rt::lang_start
             at /rustc/4560ea788cb760f0a34127156c78e2552949f734/src/libstd/rt.rs:64
  27: error_handle::main
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

fn happen_panic() {
    // let x = None::<i32>;
    // x.unwrap();
    panic!("panic message");
}

fn catch_panic() {
    panic::set_hook(Box::new(|panic_info| {
        // do nothing
        if let Some(s) = panic_info.payload().downcast_ref::<&str>() {
            println!("panic occurred: {:?}", s);
        } else {
            println!("panic occurred");
        }
    }));
    let result = panic::catch_unwind(happen_panic);
    println!("======");
    println!("{:?}", result.err().unwrap());
    println!("======");
}

    let s = String::from("str");
    println!("0x{:x}", &s as *const String as usize);
    // 所有权转移的同时进行栈内存拷贝
    let s2 = s;
    println!("0x{:x}", &s2 as *const String as usize);

    let slen = mem::size_of::<String>();
    println!("{}", slen);

    // raw-string-literals
    // https://doc.rust-lang.org/reference/tokens.html#raw-string-literals
    // https://rahul-thakoor.github.io/rust-raw-string-literals/
    println!(r"多行字符串
    多行字符串，不能表达引号
    ");
    println!(r#"多行字符串
    多行字符串，不能表达引号""""" 可以表达引号，可以表达#号
    不能表达"紧接着#
    "#);
    println!(r##"多行字符串
    多行字符串，不能表达引号""""" 可以表达引号，可以表达#号，可以表达"#
    不能表达"紧接着##
    "##);

    {                      // s 非法，因为还没有声明
        let s = "hello";   // s 是合法的
        println!("{}", s);
        // 使用 s 做一些事情
    }                      // 超出作用域 s 不可用

    let s = String::from("hello");    // 这样声明表示不可变，从一个字符串字面量创建String

    let mut s = String::from("hello"); // 声明可变的string

    s.push_str(", world!"); // push_str() 字符串拼接

    println!("{}", s); // 将打印出 `hello, world!`

    {
        let x = 5;
        let y = x; // x 分配在栈上，x将copy到y上，所以x, y都可以访问
        println!("{}", x);
    }

    let s1 = String::from("hello");
    let s2 = s1; // 可以称之为所有权转移，浅拷贝，同时让s1失效

    // println!("{}, world!", s1); // 报错：borrow of moved value: `s1` value borrowed here after moverustc(E0382)

    {
        #[derive(Debug)]
        struct S {
            a: String,
            b: String,
        }
        let mut c: String;
        let mut d: String;
        let mut s = S {
            a: String::from("a"),
            b: String::from("b")
        };
        c = s.a;
        d = s.b;
        println!("{:?}", c);
        println!("{:?}", d);
        // println!("{:?}", s); // borrow of moved value: `s` move occurs because `s.a` has type `std::string::String`, which does not implement the `Copy` trait
    }

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

        println!("s1 = {}, s2 = {}", s1, s2); // 不会报错
    }

    {
        #[derive(Debug)]
        struct S {
            a: String,
            b: String,
        }
        let mut s = S {
            a: String::from("a"),
            b: String::from("b")
        };
        let mut c = s.a;
        // println!("{:?}", s); // borrow of moved value: `s` move occurs because `s.a` has type `std::string::String`, which does not implement the `Copy` trait
    }
    {
        // Copy
        #[derive(Debug, Clone, Copy)]
        struct S {
            a: i32,
            b: i32,
        }
        let owner = S {
            a: 1,
            b: 2
        };
        let new_owner = owner;
        println!("{:?}", owner);
    }

    {
        let s1 = String::from("hello");
        let s1 = String::from("hello"); // 变量覆盖不会带来内存回收，在花括号结束后自动回收
        let s1 = String::from("hello");
    }

    let s = String::from("hello");  // s 进入作用域

    takes_ownership(s);             // s 被移动到函数内部
                                    // ... 不在合法
    // println!("所有权已转移 {}", s); // 报错
    let x = 5;                      // x 进入作用域

    makes_copy(x);                  // x 所有权转移到函数
                                    // but i32 被拷贝，所以x仍能访问
                                    // 可以使用x
    println!("标量数据类型直接拷贝，仍然可访问{}", x);

fn takes_ownership(some_string: String) { // some_string 进入作用域
    println!("{}", some_string);
} // 在这, some_string 超出作用域 `drop` 被调用. 返回
  // 内存被释放

fn makes_copy(some_integer: i32) { // some_integer 进入作用域
    println!("{}", some_integer);
} // 在这, some_integer 超出作用域. 没有什么发生.

    let s1 = gives_ownership();         // 函数返回值的所有权转移到s1
                                        // value into s1

    let s2 = String::from("hello");     // s2 进入作用域

    let s3 = takes_and_gives_back(s2);  // s2 移动到函数内
                                        // takes_and_gives_back, 返回值
                                        // 移动到s3
    // println!("s2 {}", s2); // 报错
    println!("s3 {}", s3);



fn gives_ownership() -> String {             // gives_ownership 所有权将移动到作用域内
                                             // 返回值所有权将移动到调用者所在作用域

    let some_string = String::from("hello"); // some_string 进入作用域

    some_string                              // some_string 所有权将移动到调用者所在作用域
}

// takes_and_gives_back 将接受一个参数并返回一个参数
fn takes_and_gives_back(a_string: String) -> String { // a_string 进入
                                                      // 作用域

    a_string  // a_string 所有权将移动到调用者所在作用域
}

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

    let (s2, len) = calculate_length(s1);

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

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

    (s, length)
}

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

        let len = calculate_length2(&s1);

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

fn calculate_length2(s: &String) -> usize {
    s.len()
}

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

    change(&mut s);
}

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

    {
        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;
    }

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

        let r1 = &s; // no problem
        let r2 = &s; // no problem
        // let r3 = &mut s; // BIG PROBLEM：cannot borrow `s` as mutable because it is also borrowed as immutable

        // println!("{}, {}, and {}", r1, r2, r3);
    }

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

let r1 = &s; // no problem
let r2 = &s; // no problem
println!("{} and {}", r1, r2);
// r1 and r2 are no longer used after this point

let r3 = &mut s; // no problem
println!("{}", r3);

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String { // 报错引用超出变量作用域
    let s = String::from("hello");

    &s
}

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

let hello = &s[0..5];
let world = &s[6..11];

    {
        let mut s = String::from("hello world");
        s.push_str(" 123");
        let word = first_word(&s);

        // s.clear(); // error! 类似引用计数机制，因为 work 引用了 s

        println!("the first word is: {}", word);
    }
    {
        let mut s = String::from("hello world");

        let word = first_word(&s);

        // s.clear(); // error! cannot borrow `s` as mutable because it is also borrowed as immutable

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

fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

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

    &s[..]
}

// 结构体
struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

// 方便的构造函数
fn build_user(email: String, username: String) -> User {
    User {
        email, // 相同可以省略
        username,
        active: true,
        sign_in_count: 1,
    }
}

// 元组结构体
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let user1 = User {
        email: String::from("[email protected]"),
        username: String::from("username123"),
        active: true,
        sign_in_count: 1,
    };
    println!("User: username={} email={} sign_in_count={} active={}", user1.username, user1.email, user1.sign_in_count, user1.active);
    let user1_1 = build_user(String::from("[email protected]"), String::from("test"));
    let user2 = User {
        email: String::from("[email protected]"),
        username: String::from("anotherusername567"),
        ..user1 // 从其他实例中拷贝
    };

    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);

    println!("Hello, world!");
}

struct User {
    username: &str, // 报错
    email: &str, //  报错
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        email: "[email protected]",
        username: "someusername123",
        active: true,
        sign_in_count: 1,
    };
}

#[derive(Debug)] // 注解
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle { //实现方法
    fn area(&self) -> u32 {
        self.width * self.height
    }

}

impl Rectangle {
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };

    println!("rect1 is {:?}", rect1);
    println!("rect1 is {:#?}", rect1);

    println!(
        "The area of the rectangle is {} square pixels.",
        rect1.area()
    );

    let rect1 = Rectangle { width: 30, height: 50 };
    let rect2 = Rectangle { width: 10, height: 40 };
    let rect3 = Rectangle { width: 60, height: 45 };

    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}

    struct S {
        a: i32
    }
    impl S {
        fn a(self) {
            println!("fn a(self) {}", self.a);
        }
        fn b(mut self) {
            println!("fn b(mut self) {}", self.a);
        }
        fn c(&self) {
            println!("fn c(&self) {}", self.a);
        }
        fn d(&mut self) {
            println!("fn d(&mut self) {}", self.a);
        }
        fn e(self: std::pin::Pin<&Self>) {
            println!("fn e(self: std::pin::Pin<&Self>) {}", self.a)
        }
    }
    {
        let s = S {a:1};
        s.a();
        // s.a();  // use of moved value: `s`
        let s1 = S {a:1};
        let sr = &s1;
        // sr.a(); // cannot move out of `*sr` which is behind a shared reference
    }
    {
        let s = S {a:1};
        s.b();
        // s.b();  // use of moved value: `s`
        let mut s1 = S {a:1};
        let sr = &mut s1;
        // sr.b(); // cannot move out of `*sr` which is behind a mutable reference
    }
    {
        let s = S {a:1};
        s.c();
        s.c();
    }
    {
        let s = S {a:1};
        // s.d();  // cannot borrow `s` as mutable, as it is not declared as mutable
        let mut s = S {a:1};
        s.d();
        s.d();
    }
    {
        let s = S {a:1};
        let sp = std::pin::Pin::new(&s);
        sp.e();
    }

// 定义枚举
enum IpAddrKind {
    V4,
    V6,
}

    // 使用枚举
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

// 枚举值作为函数参数
fn route(ip_type: IpAddrKind) {

}

    // 调用参数为枚举方法
    route(four);

// 枚举值作为结构体成员
struct IpAddr {
    kind: IpAddrKind,
    address: String,
}

    // 使用枚举结构体
    let home = IpAddr {
        kind: IpAddrKind::V4,
        address: String::from("127.0.0.1"),
    };
    let loopback = IpAddr {
        kind: IpAddrKind::V6,
        address: String::from("::1"),
    };

// 将数值与枚举属性绑定
enum IpAddr2 {
    V4(String),
    V6(String),
}

    let home = IpAddr2::V4(String::from("127.0.0.1"));
    let loopback = IpAddr2::V6(String::from("::1"));

// 标准库中ip的封装
struct Ipv4Addr {
    // --snip--
}
struct Ipv6Addr {
    // --snip--
}
enum IpAddr3 {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}

//更复杂的关联数据的例子
enum Message {
    Quit, //没有关联任何数据
    Move { x: i32, y: i32 }, //包含一个匿名结构体
    Write(String), //包含单独一个 String
    ChangeColor(i32, i32, i32), //包含三个 i32
}

// 结构体同样支持方法
impl Message {
    fn call(&self) {
        // 在这里定义方法体
    }
}

    // 方法调用
    let m = Message::Write(String::from("hello"));
    m.call();

// 标准库中的enum实现例子
/*
enum Option<T> {
    Some(T),
    None,
}
*/
    // Option例子
    let some_number = Some(5);
    let some_string = Some("a string");

    let absent_number: Option<i32> = None;

    let x: i8 = 5;
    let y: Option<i8> = Some(5);

    // let sum = x + y; //报错 no implementation for `i8 + std::option::Option<i8>`

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u32 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

enum Coin2 {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn value_in_cents2(coin: Coin2) -> u32 {
    match coin {
        Coin2::Penny => 1,
        Coin2::Nickel => 5,
        Coin2::Dime => 10,
        Coin2::Quarter(state) => {
            println!("State quarter from {:?}!", state);
            25
        }
    }
}

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 {
        1 => println!("one"),
        3 => println!("three"),
        5 => println!("five"),
        7 => println!("seven"),
        _ => (),
    }

let some_u8_value = Some(0u8);
match some_u8_value {
    Some(3) => println!("three"),
    _ => (),
}

if let Some(3) = some_u8_value {
    println!("three");
}

    let mut count = 0;
    let coin = Coin2::Dime;
    match coin {
        Coin2::Quarter(state) => println!("State quarter from {:?}!", state),
        _ => count += 1,
    }

    let mut count = 0;
    let coin1 = Coin2::Dime;
    if let Coin2::Quarter(state) = coin1 {
        println!("State quarter from {:?}!", state);
    } else {
        count += 1;
    }

match VALUE {
    PATTERN => EXPRESSION,
    PATTERN => EXPRESSION,
    PATTERN => EXPRESSION,
    _ => EXPRESSION, // 可选项类似于Default，不加的话，编译器会检测是否已经穷举所有的值
}

// 模式匹配字面值
let x = 1;

match x {
    1 => println!("one"),
    2 => println!("two"),
    3 => println!("three"),
    _ => println!("anything"),
}

// 匹配命名变量

    let x = Some(5);
    let y = 10;

    match x {
        Some(50) => println!("Got 50"),
        Some(y) => println!("Matched, y = {:?}", y),
        _ => println!("Default case, x = {:?}", x),
    }

    println!("at the end: x = {:?}, y = {:?}", x, y);

// 多模式匹配

    let x = 1;

    match x {
        1 | 2 => println!("one or two"),
        3 => println!("three"),
        _ => println!("anything"),
    }

// 通过 ..= 匹配值的范围

let x = 5;

match x {
    1..=5 => println!("one through five"),
    _ => println!("something else"),
}

let x = 'c';

match x {
    'a'..='j' => println!("early ASCII letter"),
    'k'..='z' => println!("late ASCII letter"),
    _ => println!("something else"),
}

// 解构结构体
struct Point {
    x: i32,
    y: i32,
}

    let p = Point { x: 0, y: 7 };

    match p {
        Point { x, y: 0 } => println!("On the x axis at {}", x),
        Point { x: 0, y } => println!("On the y axis at {}", y),
        Point { x, y } => println!("On neither axis: ({}, {})", x, y),
    }

// 解构枚举

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

    let msg = Message::ChangeColor(0, 160, 255);

    match msg {
        Message::Quit => {
            println!("The Quit variant has no data to destructure.")
        }
        Message::Move { x, y } => {
            println!(
                "Move in the x direction {} and in the y direction {}",
                x,
                y
            );
        }
        Message::Write(text) => println!("Text message: {}", text),
        Message::ChangeColor(r, g, b) => {
            println!(
                "Change the color to red {}, green {}, and blue {}",
                r,
                g,
                b
            )
        }
    }

// 解构嵌套的结构体和枚举

enum Color {
   Rgb(i32, i32, i32),
   Hsv(i32, i32, i32),
}

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(Color),
}

    let msg = Message::ChangeColor(Color::Hsv(0, 160, 255));

    match msg {
        Message::ChangeColor(Color::Rgb(r, g, b)) => {
            println!(
                "Change the color to red {}, green {}, and blue {}",
                r,
                g,
                b
            )
        }
        Message::ChangeColor(Color::Hsv(h, s, v)) => {
            println!(
                "Change the color to hue {}, saturation {}, and value {}",
                h,
                s,
                v
            )
        }
        _ => ()
    }

// 结构元组和结构体
let ((feet, inches), Point {x, y}) = ((3, 10), Point { x: 3, y: -10 });

    let favorite_color: Option<&str> = None;
    let is_tuesday = false;
    let age: Result<u8, _> = "34".parse();

    if let Some(color) = favorite_color {
        println!("Using your favorite color, {}, as the background", color);
    } else if is_tuesday {
        println!("Tuesday is green day!");
    } else if let Ok(age) = age {
        if age > 30 {
            println!("Using purple as the background color");
        } else {
            println!("Using orange as the background color");
        }
    } else {
        println!("Using blue as the background color");
    }

    let mut stack = Vec::new();

    stack.push(1);
    stack.push(2);
    stack.push(3);

    while let Some(top) = stack.pop() {
        println!("{}", top);
    }

    let v = vec!['a', 'b', 'c'];

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

    let PATTERN = EXPRESSION;
    let x = 5;
    let (x, y, z) = (1, 2, 3);
    let (x, _, _) = (1, 2, 3);

// 解构结构体
struct Point {
    x: i32,
    y: i32,
}

    let p = Point { x: 0, y: 7 };

    let Point { x: a, y: b } = p;
    assert_eq!(0, a);
    assert_eq!(7, b);

    let Point { x, y } = p;
    assert_eq!(0, x);
    assert_eq!(7, y);

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

fn main() {
    let point = (3, 5);
    print_coordinates(&point);
}

fn foo(_: i32, y: i32) {
    println!("This code only uses the y parameter: {}", y);
}


    foo(3, 4);

    let mut setting_value = Some(5);
    let new_setting_value = Some(10);

    match (setting_value, new_setting_value) {
        (Some(_), Some(_)) => {
            println!("Can't overwrite an existing customized value");
        }
        _ => {
            setting_value = new_setting_value;
        }
    }

    println!("setting is {:?}", setting_value);

    let numbers = (2, 4, 8, 16, 32);

    match numbers {
        (first, _, third, _, fifth) => {
            println!("Some numbers: {}, {}, {}", first, third, fifth)
        },
    }

    let _x = 5;
    let y = 10;

// 下划线开头的变量解构任然会获取所有权
let s = Some(String::from("Hello!"));

if let Some(_s) = s {
    println!("found a string");
}

// println!("{:?}", s); // 报错

// _ 不会获取所有权

let s = Some(String::from("Hello!"));

if let Some(_) = s {
    println!("found a string");
}

println!("{:?}", s);

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),
}

    let numbers = (2, 4, 8, 16, 32);

    match numbers {
        (first, .., last) => {
            println!("Some numbers: {}, {}", first, last);
        },
    }

    let numbers = (2, 4, 8, 16, 32);

    // match numbers { // 有歧义报错
    //     (.., second, ..) => {
    //         println!("Some numbers: {}", second)
    //     },
    // }
}

let num = Some(4);

match num {
    Some(x) if x < 5 => println!("less than five: {}", x),
    Some(x) => println!("{}", x),
    None => (),
}

// 与 | 配合使用

let x = 4;
let y = false;

match x {
    4 | 5 | 6 if y => println!("yes"), // 优先级为 (4 | 5 | 6) if y => ...
    _ => println!("no"),
}

enum Message {
    Hello { id: i32 },
}

let msg = Message::Hello { id: 5 };

match msg {
    Message::Hello { id: id_variable @ 3..=7 } => {
        println!("Found an id in range: {}", id_variable)
    },
    Message::Hello { id: 10..=12 } => {
        println!("Found an id in another range")
    },
    Message::Hello { id } => {
        println!("Found some other id: {}", id)
    },
}

use std::thread;
use std::time::Duration;


/// 一个生成训练计划的程序
/// 根据用户提供的强度值和随机因子计算接下来要做的事情
fn generate_workout(intensity: u32, random_number: u32) {
    // 用来计算运动项目的次数
    let expensive_closure = |num| { // 一个闭包，类型参数根据下方调用传的参数推断出来
        println!("缓慢计算中...");
        thread::sleep(Duration::from_secs(2));
        num
    };

    if intensity < 25 {
        println!(
            "今天, 先做 {} 个 俯卧撑 !",
            expensive_closure(intensity) // 在此处推断出闭包的参数类型和返回值类型
        );
        println!(
            "接下来, 在做 {} 个 仰卧起坐 !",
            expensive_closure(intensity) // 此处传参和返回值必须与第一次调用一致
        );
        // expensive_closure(1.2); // 报错：expected u32, found floating-point number
    } else {
        if random_number == 3 {
            println!("今天休息一下！记住要保持水分！ ");
        } else {
            println!(
                "今天, 跑 {} 分钟步!",
                expensive_closure(intensity)
            );
        }
    }
}

    generate_workout(25, 10);

fn add_one(a: u32, version: u32) -> u32 {
    fn  add_one_v1   (x: u32) -> u32 { x + 1 }; // 这是定义了一个函数
    let add_one_v2 = |x: u32| -> u32 { x + 1 }; // 定义闭包方式1
    // 以下两种定义必须在作用域内使用才能使编译器推断出参数类型，不适用的将报错，让用户明确声明类型
    let add_one_v3 = |x|             { x + 1 }; // 定义闭包方式2
    let add_one_v4 = |x|               x + 1  ; // 定义闭包方式3
    let add_one_v5 = | |               a + 1  ; // 闭包可以捕获作用域内的变量，但是函数不能
    // fn  add_one_v6   () -> u32       { a + 1 }; // 报错：can't capture dynamic environment in a fn item


    match version {
        1 => add_one_v1(a),
        2 => add_one_v2(a),
        3 => add_one_v3(a),
        4 => add_one_v4(a),
        5 => add_one_v5(),
        _ => a+1,
    }
}

    add_one(1,5);

struct Cacher<T>
    where T: Fn(u32) -> u32 // 闭包有三种triat类型参见下文
{
    calculation: T,
    value: Option<u32>,
}

impl<T> Cacher<T>
    where T: Fn(u32) -> u32
{
    fn new(calculation: T) -> Cacher<T> {
        Cacher {
            calculation,
            value: None,
        }
    }

    fn value(&mut self, arg: u32) -> u32 {
        match self.value {
            Some(v) => v,
            None => {
                let v = (self.calculation)(arg);
                self.value = Some(v);
                v
            },
        }
    }
}


    let mut add_one_cacher = Cacher::new(|x: u32| x+1);
    println!("{}", add_one_cacher.value(1));

fn main() {

    let x = vec![1, 2, 3];

    let equal_to_x = move |z| z == x; // 强制指定为FnOnce，且将 x 所有权移动到闭包中，当闭包执行完毕x将被回收

    // println!("can't use x here: {:?}", x); // 报错： value borrowed here after moverustc(E0382)

    let y = vec![1, 2, 3];

    assert!(equal_to_x(y));
}

        trait FnOnce2<Args> {
            type Output;
            fn call_once(self, args: Args) -> Self::Output;
        }

        struct Adder {
            c: i32,
        }

        impl FnOnce2<(i32, i32)> for Adder {
            type Output = i32;
            fn call_once(self, args: (i32, i32)) -> Self::Output {
                return args.0 + args.1 + self.c
            }
        }
        let c = 2;
        let add = |a: i32, b: i32| a + b + c;
        println!("add(1,2) = {}", add(1,2));
        let add2 = Adder{c};
        println!("add2(1,2) = {}", add2.call_once((1,2)));

        // 迭代器原理与直接使用
        // Iterator 特质定义的方法如下
        // pub trait Iterator {
        //     // 这段代码表明实现 Iterator trait 要求同时定义一个 Item 类型，这个 Item 类型被用作 next 方法的返回值类型。换句话说，Item 类型将是迭代器返回元素的类型。
        //     type Item;
        //     fn next(&mut self) -> Option<Self::Item>;
        //     // 此处省略了方法的默认实现
        // }
        let values = vec![1, 2, 3];
        // iter 必须声明为可变的
        let mut iter = values.iter(); // 声明为 pub fn iter(&self) -> Iter<'_, T>
        println!("迭代器原理与直接使用");
        loop {
            match iter.next() {
                Some(val) => println!("{}", val),
                None => break,
            }
        }

        println!("使用可变迭代器，所有值+1");
        let mut values = vec![1, 2, 3];

        let mut iter = values.iter_mut(); // 声明为 pub fn iter_mut(&mut self) -> IterMut<'_, T>
        // 修改值
        loop {
            match iter.next() {
                Some(val) => {
                    *val = *val + 1;
                },
                None => break,
            }
        }
        // 打印查看
        for val in values.iter() {
            println!("{}", val);
        }

        // 迭代器常见用法
        // https://rustforce.net/article?id=3874fb6c-30d8-4409-b78f-6d39763074c6
        let v = vec![1, 2, 3];
        println!("同时获取索引号");
        for (i, n) in v.iter().enumerate() {
            println!("v[{}] = {}", i, n);
        }
        println!("最大最小值");
        let max = v.iter().max();
        let min = v.iter().min();
        println!("max = {:?}, min = {:?}", max, min);

        // 迭代器流式处理
        println!("迭代器流式处理，高阶函数（消费）");
        let v1 = vec![1, 2, 3];
        // let v1_iter = v1.iter();
        // let total: i32 = v1_iter.sum();
        println!("sum = {}", v1.iter().sum::<i32>());
        let v2: Vec<_> = v1.iter().map(|x| x + 1).collect();
        println!("{:?}", v2);
        let v3: Vec<_> = v1.iter().filter(|&&x| x != 1).collect();
        println!("{:?}", v3);
        let v4 = (0..10).filter(|x| x % 2 == 0).collect::<Vec<_>>();
        println!("{:?}", v4);
        let v5 = v1.iter().fold(0, |acc, x| acc + x * x);
        println!("{}", v5);
        println!("{:?}", v1.iter().rev()); // 翻转
        println!("{:?}", v1.iter().chain( (vec![4, 5, 6]).iter() ).collect::<Vec<_>>()); // 连接
        println!("{:?}", v1.iter().zip( (vec![4, 5, 6]).iter() ).collect::<Vec<_>>()); // 连接
        // 更多工具: https://docs.rs/itertools/0.6.0/itertools

fn for_in_debug(){
    // https://doc.rust-lang.org/std/iter/index.html
    // let values = vec![1, 2, 3];
    // for val in values {
    //     println!("Got: {}", val);
    // }
    let values = vec![1, 2, 3];
    {
        let result = match IntoIterator::into_iter(values) {
            mut iter => loop {
                let next;
                match iter.next() {
                    Some(val) => next = val,
                    None => break,
                };
                let x = next;
                let () = { println!("{}", x); };
            },
        };
        result
    }
}

fn for_in_debug2() {
    // for val in values {
    //     println!("Got: {}", val);
    // }
    let values:Vec<i32> = vec![1, 2, 3];
    {
        // let mut iter = IntoIterator::into_iter(values);
        // IntoIterator 特质定义内容如下
        // pub trait IntoIterator {
        //     type Item;

        //     type IntoIter: Iterator<Item=Self::Item>;

        //     fn into_iter(self) -> Self::IntoIter;
        // }
        // IntoIterator 的作用 1.返回一个迭代器 2.所有权转移
        let result = loop {
            let next;
            let next_option = iter.next();
            if next_option.is_some() {
                next = next_option.unwrap();
            } else {
                break;
            }
            let x = next;
            let () = { println!("{}", x); };
        };
        result
    }
}
fn main() {
    {
        // for 语法糖原理探究
        // https://doc.rust-lang.org/std/iter/index.html#implementing-iterator
        let values = vec![1, 2, 3];
        // 使用 for 迭代迭代器（注意所有权已经转移）
        println!("for 语法糖原理探究");
        for val in values.iter() { // 这样写不会转移values的所有权，values.iter()返回值的所有权被转移了
            println!("{}", val);
        }
        for val in values {
            println!("{}", val);
        }
        // println!("{:?}", values); // 报错
        // 以上将编译成如下内容
        for_in_debug();
        // 原理如下
        for_in_debug2();
    }
}

// 自定义结构体

pub struct MyRange {
    start: i32,
    end: i32,
    step: i32,
}

impl MyRange {
    pub fn new(start: i32, end: i32, step: i32) -> Self {
        MyRange { start, end, step }
    }

    pub fn iter(&self) -> MyRangeIteratorRef<'_> { // '_ 表示匿名生命周期
    // pub fn iter<'a>(&'a self) -> MyRangeIteratorRef<'a> {
        MyRangeIteratorRef {
            range: self,
            now: self.start,
        }
    }
}

// 为自定义结构体实现的迭代器（为引用类型实现）

pub struct MyRangeIteratorRef<'a> {
    range: &'a MyRange,
    now: i32,
}

impl Iterator for MyRangeIteratorRef<'_> {
    type Item = i32;
    fn next(&mut self) -> Option<i32> {
        if self.now == self.range.end {
            None
        } else {
            let r = Some(self.now);
            self.now += self.range.step;
            r
        }
    }
}

impl<'a> IntoIterator for &'a MyRange { // 这个impl是对 MyRange 引用类型的实现
    type Item = i32;
    type IntoIter = MyRangeIteratorRef<'a>;

    fn into_iter(self: &'a MyRange) -> Self::IntoIter { // 这里的self是个引用类型
        self.iter()
    }
}

// 为自定义结构体实现的迭代器（为生命周期转移实现）

pub struct MyRangeIterator{
    range: MyRange,
    now: i32,
}

impl Iterator for MyRangeIterator {
    type Item = i32;
    fn next(&mut self) -> Option<i32> {
        if self.now == self.range.end {
            None
        } else {
            let r = Some(self.now);
            self.now += self.range.step;
            r
        }
    }
}

impl IntoIterator for MyRange { // 这个方法是对 MyRange 本身类型的实现
    type Item = i32;
    type IntoIter = MyRangeIterator;

    fn into_iter(self: MyRange) -> Self::IntoIter { // 这里的self是个本身类型
        MyRangeIterator {
            now: self.start,
            range: self,
        }
    }
}


    // 自定义迭代器
    // 参考 https://stackoverflow.com/questions/30218886/how-to-implement-iterator-and-intoiterator-for-a-simple-struct
    println!("自定义迭代器");
    let r = MyRange::new(0, 10, 1);
    for i in r.iter() {
        println!("{}", i);
    }
    for i in r {  // 调用了 `MyRange::into_iter`
        println!("{}", i);
    }
    // println!("{}", r.start); // 报错：borrow of moved value: `r`
    // 重复问题：暂时无法解决，只能期望 GAT 特性 https://github.com/rust-lang/rfcs/blob/master/text/1598-generic_associated_types.md
    let r2 = &MyRange::new(0, 10, 1);
    for i in r2 { // 调用了 `&MyRange::into_iter`
        println!("{}", i);
    }
    println!("{}", r2.start); // 不报错

cargo new --lib restaurant

// mod 定义了一个模块
mod front_of_house {
    // 定义了一个子模块
    mod hosting {
        // 模块的内容
        fn add_to_waitlist() {}

        fn seat_at_table() {}
    }

    mod serving {
        fn take_order() {}

        fn server_order() {}

        fn take_payment() {}
    }

}

crate
 └── front_of_house
     ├── hosting
     │   ├── add_to_waitlist
     │   └── seat_at_table
     └── serving
         ├── take_order
         ├── serve_order
         └── take_payment

// Version1： 模拟餐馆前台的模块
// mod 定义了一个模块
mod front_of_house {
    // 定义了一个子模块
    pub mod hosting {
        // 模块的内容
        pub fn add_to_waitlist() {}

        fn seat_at_table() {}
    }

    pub mod serving {
        pub fn take_order() {}

        fn server_order() {}

        fn take_payment() {}
    }

}

pub fn eat_at_restaurant() {

    // 绝对路径调用
    crate::front_of_house::hosting::add_to_waitlist();

    // 相对路径调用：当前内容在 crate 模块，相对于 crate
    front_of_house::hosting::add_to_waitlist();
}

fn serve_order() {}

mod back_of_house {
    fn fix_incorrect_order() {
        cook_order();
        super::serve_order(); // 调用父模块中的成员
    }

    fn cook_order() {}
}

    // 定义了一个公有的结构体
    pub struct Breakfast {
        pub toast: String, // 公有字段
        seasonal_fruit: String, // 默认是私有字段
    }

    // 实现结构体方法
    impl Breakfast {
        pub fn summer(toast: &str) -> Breakfast {
            Breakfast {
                toast: String::from(toast),
                seasonal_fruit: String::from("peaches"),
            }
        }
    }

    // 定义一个公有结构体
    pub enum Appetizer {
        Soup, // 默认是公有
        Salad, // 默认是公有
    }

    // 夏天订购黑麦面包早餐 Order a breakfast in the summer with Rye toast
    let mut meal = back_of_house::Breakfast::summer("Rye");
    // 改变主意，想吃什么面包 Change our mind about what bread we'd like
    meal.toast = String::from("Wheat"); // 修改公有字段
    println!("I'd like {} toast please", meal.toast);

    // The next line won't compile if we uncomment it; we're not allowed
    // to see or modify the seasonal fruit that comes with the meal
    // 如果我们取消注释，则下一行将不会编译；我们不允许
    // 查看或修改随餐提供的时令水果
    // meal.seasonal_fruit = String::from("blueberries"); // 不可以修改

    // 公有的可直接访问
    let order1 = back_of_house::Appetizer::Soup;
    let order2 = back_of_house::Appetizer::Salad;

use crate::front_of_house::hosting;

pub fn eat_at_restaurant1() {
    hosting::add_to_waitlist();
    hosting::add_to_waitlist();
    hosting::add_to_waitlist();
}

use crate::front_of_house::hosting::add_to_waitlist; // 直接引入函数

pub fn eat_at_restaurant2() {
    add_to_waitlist();
    add_to_waitlist();
    add_to_waitlist();
}

use std::fmt::Result;
use std::io::Result as IoResult; // 重命名

// 引入并暴露，这样在外部就可以通过 类似 serving::take_order 方式调用
// 相当于在当前作用域定义了 serving 模块并 pub
pub use crate::front_of_house::serving;

use rand::Rng;

use std::collections::HashMap;

use std::{cmp::Ordering, alloc};
use std::io::{self, Write};

use std::collections::*;

mod front_of_house2;

pub use crate::front_of_house2::hosting as hosting2 ;

pub fn eat_at_restaurant3() {
    hosting2::add_to_waitlist();
    hosting2::add_to_waitlist();
    hosting2::add_to_waitlist();
}

mod front_of_house3;

pub mod hosting;

pub fn add_to_waitlist() {}

pub mod hosting;

pub fn add_to_waitlist() {}

[profile.dev]
opt-level = 0 # 优化级别

[profile.release]
opt-level = 3

/// 将给定的数字加一
///
/// # Examples
///
/// ```
/// let arg = 5;
/// let answer = my_crate::add_one(arg);
///
/// assert_eq!(6, answer);
/// ```
pub fn add_one(x: i32) -> i32 {
    x + 1
}

//! # My Crate
//!
//! `my_crate` 是一个使得特定计算更方便的
//! 工具集合

/// 将给定的数字加一。
// --snip--

//! # Art
//!
//! 一个描述美术信息的库。

pub use self::kinds::PrimaryColor;
pub use self::kinds::SecondaryColor;
pub use self::utils::mix;

pub mod kinds {
    // --snip--
}

pub mod utils {
    // --snip--
}

use art::PrimaryColor;
use art::mix;

fn main() {
    // --snip--
}

mkdir workspace
cd workspace
vim Cargo.toml

[workspace]

members = [
    "adder",
    "add-one",
]

cargo new adder
cargo new add-one --lib

[dependencies]
rand = "0.5.5"

pub fn add_one(x: i32) -> i32 {
    x + 1
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        assert_eq!(3, add_one(2));
    }
}

[dependencies]

add-one = { path = "../add-one" }

use add_one;

fn main() {
    let num = 10;
    println!("Hello, world! {} plus one is {}!", num, add_one::add_one(num));
}

cargo test
cargo test -p add-one
cargo run -p adder
cargo build

.
├── Cargo.lock
├── Cargo.toml
├── add-one
│   ├── Cargo.toml
│   └── src
├── adder
│   ├── Cargo.toml
│   └── src
└── target
    └── debug

    // 1. Vector 可变数组

    // 通过构造函数创建
    let v: Vec<i32> = Vec::new();
    // 通过宏创建，可以推断出类型
    let v = vec![1, 2, 3];

    // 更新Vector
    let mut v = Vec::new(); // 必须是不可变，否则报错
    v.push(5);
    v.push(6);
    v.push(7);
    v.push(8);

    // 垃圾回收
    {
        let v = vec![1,2,3,4,5];
        // 处理变量
    } //  <- 这里 v 离开作用域并被丢弃，包括内部的整数元素

    // 读取元素
    let v = vec![1,2,3,4,5];
    let third: &i32 = &v[2];
    println!("第三个元素是 {}", third);
    match v.get(2) { // get 返回一个Option
        Some(third) => println!("第三个元素是 {}", third),
        None => println!("没有第三个元素"),
    }

    let v = vec![1, 2, 3, 4, 5];
    // 使用 [] 访问不存在的元素将触发 panic
    // let does_not_exist = &v[100];
    // 使用get会返回一个None 不会触发异常
    let does_not_exist = v.get(100);

    let mut v = vec![1, 2, 3, 4, 5];
    let first = &v[0];
    // 此句将编译报错，因为上一句已经将 可变的v借用给不可便的first了
    // 原因是：v是可变数组，push可能触发内存分配，这样会破坏first的引用，导致引用悬空
    // v.push(6);
    println!("The first element is: {}", first);

    // 元素遍历
    let v = vec![100, 32, 57];
    for i in &v {
        println!("{}", i);
    }

    // 遍历过程中改变元素值
    let mut v = vec![100, 32, 57];
    for i in &mut v {
        *i += 50;
    }

    // 使用枚举来存储多种类型
    enum SpreadsheetCell {
        Int(i32),
        Float(f64),
        Text(String),
    }
    let row = vec![
        SpreadsheetCell::Int(3),
        SpreadsheetCell::Text(String::from("blue")),
        SpreadsheetCell::Float(10.12),
    ];

    // 访问并修改值
    let mut v = vec![1, 2, 4];
    if v[2] != 3 {
        v[2] = 3;
    }

    // 2. String 可变字符串
    // Rust 中的字符串常用的有两种：
    //   str rust核心字符串，字面量字符串类型，utf8编码
    //   String 标准库字符串，可变字符串，utf8编码
    // 除了以上两种还有其他字符串实现，比如：OsString、OsStr、CString 和 CStr

    // 创建一个空的String字符串，通过构造函数
    let mut s = String::new();

    // 通过字面量字符串&str创建字符串String
    let data = "initial contents";
    let s = data.to_string();
    // 该方法也可直接用于字符串字面值：
    let s = "initial contents".to_string();

    // 以上方法等价于 String::from
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שָׁלוֹם");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");

    // 更新字符串
    let mut s1 = String::from("foo");
    let s2 = "bar";
    s1.push_str(s2); // 并不会获取s2所有权
    println!("s2 is {}", s2);

    let mut s = String::from("lo");
    s.push('l'); // 添加一个字符

    // 字符串拼接
    let s1 = String::from("Hello, ");
    let s2 = String::from("world!");
    // + 的签名类似与： fn add(self, s: &str) -> String {
    // 注意 s1 被移动了，不能继续使用，因为self声明类型为 String 而不是 引用，所有权转移了
    // 同时 s2 使用 解引用强制多态 转换为 &str 类型（&s2[..]）所以s2仍能使用
    let s3 = s1 + &s2;

    // 使用 format! 宏进行拼接
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");
    let s = format!("{}-{}-{}", s1, s2, s3);

    // String 不支持 索引
    let s1 = String::from("hello");
    // let h = s1[0]; // 报错

    // String 内部实现为 Vec<u8> 的封装，编码方式为utf8
    // 不提供索引的原因是：utf8是边长编码。无法精确定位字符
    // str支持索引，slice，但是遇到多字节字符可能引发panic
    let hello = "Здравствуйте";
    let s = &hello[0..4]; // 实际上返回 Зд
    // let s = &hello[0..1]; // 报错，因为返回的字符串是不合法的utf8编码

    // 遍历字符串
    for c in "नमस्ते".chars() {
        println!("{}", c);
    }

    // 3. HashMap
    // key需要实现 Hash 和 Eq 特质，才能全功能使用
    // 创建
    use std::collections::HashMap;
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);
    // 通过 zip创建
    let teams  = vec![String::from("Blue"), String::from("Yellow")];
    let initial_scores = vec![10, 50];
    let scores: HashMap<_, _> = teams.iter().zip(initial_scores.iter()).collect();

    // 哈希 map 和所有权
    let field_name = String::from("Favorite color");
    let field_value = String::from("Blue");
    let mut map = HashMap::new();
    map.insert(field_name, field_value);
    // 这里 field_name 和 field_value 不再有效，
    // 尝试使用它们看看会出现什么编译错误！
    // println!("{}", field_name); // 报错
    // println!("{}", field_value); // 报错

    // 访问HashMap中的值
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);
    let team_name = String::from("Blue");
    let score = scores.get(&team_name);

    // 遍历HashMap
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);
    for (key, value) in &scores {
        println!("{}: {}", key, value);
    }

    // 更新哈希 map
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Blue"), 25);
    println!("{:?}", scores);

    // 只在键没有对应值时插入
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);
    scores.entry(String::from("Yellow")).or_insert(50);
    scores.entry(String::from("Blue")).or_insert(50);
    println!("{:?}", scores);

    // 根据旧值更新一个值
    let text = "hello world wonderful world";
    let mut map = HashMap::new();
    for word in text.split_whitespace() {
        let count = map.entry(word).or_insert(0);
        *count += 1;
    }
    println!("{:?}", map);

    // 结构体使用泛型声明
    struct Point<T> {
        x: T,
        y: T,
    }
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };

    // 结构体使用多个泛型
    struct Point1<T, U> {
        x: T,
        y: U,
    }
    let both_integer = Point1 { x: 5, y: 10 };
    let both_float = Point1 { x: 1.0, y: 4.0 };
    let integer_and_float = Point1 { x: 5, y: 4.0 };

    // 枚举中使用泛型
    enum Option<T> {
        Some(T),
        None,
    }
    enum Result<T, E> {
        Ok(T),
        Err(E),
    }

    // 为泛型实现方法
    impl<T> Point<T> {
        fn x(&self) -> &T {
            &self.x
        }
    }

    // 实现一个泛型的具象化方法
    // 本例为浮点类型的点实现计算欧拉距离的方法
    impl Point<f32> {
        fn distance_from_origin(&self) -> f32 {
            (self.x.powi(2) + self.y.powi(2)).sqrt()
        }
    }

    // 为泛型结构体实现一个泛型方法
    impl<T, U> Point1<T, U> {
        fn mixup<V, W>(self, other: Point1<V, W>) -> Point1<T, W> {
            Point1 {
                x: self.x,
                y: other.y,
            }
        }
    }

use std::fmt::Display;

fn main() {
    // 结构体使用泛型声明
    struct Point<T> {
        x: T,
        y: T,
    }
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };

    // 结构体使用多个泛型
    struct Point1<T, U> {
        x: T,
        y: U,
    }
    let both_integer = Point1 { x: 5, y: 10 };
    let both_float = Point1 { x: 1.0, y: 4.0 };
    let integer_and_float = Point1 { x: 5, y: 4.0 };

    // 枚举中使用泛型
    enum Option<T> {
        Some(T),
        None,
    }
    enum Result<T, E> {
        Ok(T),
        Err(E),
    }

    // 为泛型实现方法
    impl<T> Point<T> {
        fn x(&self) -> &T {
            &self.x
        }
    }

    // 实现一个泛型的具象化方法
    // 本例为浮点类型的点实现计算欧拉距离的方法
    impl Point<f32> {
        fn distance_from_origin(&self) -> f32 {
            (self.x.powi(2) + self.y.powi(2)).sqrt()
        }
    }

    // 为泛型结构体实现一个泛型方法
    impl<T, U> Point1<T, U> {
        fn mixup<V, W>(self, other: Point1<V, W>) -> Point1<T, W> {
            Point1 {
                x: self.x,
                y: other.y,
            }
        }
    }

    // 定义一个 特质
    pub trait Summary {
        fn summarize(&self) -> String;
    }

    // 为类型实现 trait
    pub struct NewsArticle {
        pub headline: String,
        pub location: String,
        pub author: String,
        pub content: String,
    }

    impl Summary for NewsArticle {
        fn summarize(&self) -> String {
            format!("{}, by {} ({})", self.headline, self.author, self.location)
        }
    }

    pub struct Tweet {
        pub username: String,
        pub content: String,
        pub reply: bool,
        pub retweet: bool,
    }

    impl Summary for Tweet {
        fn summarize(&self) -> String {
            format!("{}: {}", self.username, self.content)
        }
    }

    // 特质默认实现
    pub trait Summary1 {
        fn summarize(&self) -> String {
            String::from("(Read more...)")
        }
    }
    pub struct NewsArticle1 {
        pub headline: String,
        pub location: String,
        pub author: String,
        pub content: String,
    }
    impl Summary1 for NewsArticle1 {
    }
    let article = NewsArticle {
    headline: String::from("Penguins win the Stanley Cup Championship!"),
        location: String::from("Pittsburgh, PA, USA"),
        author: String::from("Iceburgh"),
        content: String::from("The Pittsburgh Penguins once again are the best
        hockey team in the NHL."),
    };
    println!("New article available! {}", article.summarize());

    // trait 作为函数参数
    pub fn notify(item: impl Summary) {
        println!("Breaking news! {}", item.summarize());
    }
    // trait 作为函数参数（Trait Bound）
    pub fn notify2<T: Summary>(item: T) {
        println!("Breaking news! {}", item.summarize());
    }

    pub fn notify3<T: Summary>(item1: T, item2: T) {
    }

    // 通过 + 指定多个 trait bound
    pub fn notify4(item: impl Summary + Display) {
    }

    pub fn notify5<T: Summary + Display>(item: T) {
    }

    // 使用where语法
    trait Debug{}
    fn some_function<T: Display + Clone, U: Clone + Debug>(t: T, u: U) -> i32 {0}
    fn some_function1<T, U>(t: T, u: U) -> i32
        where T: Display + Clone,
              U: Clone + Debug
    {
        0
    }

    // trait 作为函数返回值
    fn returns_summarizable() -> impl Summary { // 只能返回单一类型
        Tweet {
            username: String::from("horse_ebooks"),
            content: String::from("of course, as you probably already know, people"),
            reply: false,
            retweet: false,
        }
    }

    // 以下代码报错：因为只能返回单一类型
    // fn returns_summarizable1(switch: bool) -> impl Summary {
    //     if switch {
    //         NewsArticle {
    //             headline: String::from("Penguins win the Stanley Cup Championship!"),
    //             location: String::from("Pittsburgh, PA, USA"),
    //             author: String::from("Iceburgh"),
    //             content: String::from("The Pittsburgh Penguins once again are the best
    //             hockey team in the NHL."),
    //         }
    //     } else {
    //         Tweet {
    //             username: String::from("horse_ebooks"),
    //             content: String::from("of course, as you probably already know, people"),
    //             reply: false,
    //             retweet: false,
    //         }
    //     }
    // }

    // 例子：实现 largest 函数
    fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
        let mut largest = list[0];
        for &item in list.iter() {
            if item > largest {
                largest = item;
            }
        }
        largest
    }
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {}", result);

    // 使用 trait bound 有条件地实现方法
    struct Pair<T> {
        x: T,
        y: T,
    }
    impl<T> Pair<T> {
        fn new(x: T, y: T) -> Self {
            Self {
                x,
                y,
            }
        }
    }
    impl<T: Display + PartialOrd> Pair<T> {
        fn cmp_display(&self) {
            if self.x >= self.y {
                println!("The largest member is x = {}", self.x);
            } else {
                println!("The largest member is y = {}", self.y);
            }
        }
    }
}

        let a = "test".to_string();
        let b = "2";
        let c = a + b;
        use std::ops::Add;
        std::string::String::add(c, "3");

trait T {
    fn t_self(self);
    fn t_ref_self(&self);
}
struct S {
    a: i32,
}
impl T for S {
    fn t_self(self) {
    // fn t_self(self: S) {
        println!("impl T for S t_self {}", self.a);
    }
    fn t_ref_self(&self) {
    // fn t_ref_self(self: &S) {
        println!("impl T for S t_ref_self, {}", (*self).a);
    }
}
impl T for &S {
    fn t_self(self) {
        println!("impl T for &S t_self {}", (*self).a);
    }
    fn t_ref_self(&self) {
        println!("impl T for &S t_ref_self {}", (*(*self)).a);
    }
}
impl T for &mut S {
    fn t_self(self) {
        (*self).a = 5;
        println!("impl T for &mut S t_self {}", (*self).a);
    }
    fn t_ref_self(&self) {
        let tmp: & &mut S = self;
        let tmp1: &S = *tmp;
        println!("impl T for &mut S t_ref_self {}", (*tmp1).a);
    }
}
{
    let s = S {a:1};
    s.t_self();  // impl T for S t_self 1
    let s = S {a:1};
    s.t_ref_self();  // impl T for S t_ref_self, 1
    &s.t_ref_self();  // impl T for S t_ref_self, 1
}
{
    let s = S {a:1};
    T::t_self(&s);  // impl T for &S t_self 1
    T::t_ref_self(&&s);  // impl T for &S t_ref_self 1
}
{
    let mut s = S {a:1};
    T::t_self(&mut s);  // impl T for &mut S t_self 5
    let mut s = S {a:1};
    T::t_ref_self(& &mut s);  // impl T for &mut S t_ref_self 1s
}

&i32        // 引用
&'a i32     // 带有显式生命周期的引用
&'a mut i32 // 带有显式生命周期的可变引用

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
}

    // 1. 生命周期避免了悬垂引用
    // {
    //     let r; // 不可便变量只允许赋值一次
    //     {
    //         let x = 5;
    //         r = &x; // Error `x` does not live long enough，生命周期不同借用检查器不允许
    //     }
    //     println!("r: {}", r);
    // }

    // 2. 生命周期一致才可以
    {
        let x = 5;            // ----------+-- 'b
                              //           |
        let r = &x;           // --+-- 'a  |
                              //   |       |
        println!("r: {}", r); //   |       |
                              // --+       |
    }

    // 3. 函数中的泛型生命周期
    // 'a 表示一个生命周期注解，表示x、y参数和返回值必须拥有相同的生命周期
    // 调用时，'a 取x、y最小的生命周期
    fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
        if x.len() > y.len() {
            x
        } else {
            y
        }
    }
    // 正确调用，'a = string2 的生命周期
    {
        let string1 = String::from("long string is long");
        {
            let string2 = String::from("xyz");
            let result = longest(string1.as_str(), string2.as_str());
            println!("The longest string is {}", result);
        }
    }
    // // 错误调用，'a = string2 的生命周期，result是 'a 的父生命周期
    // {
    //     let string1 = String::from("long string is long");
    //     let result;
    //     {
    //         let string2 = String::from("xyz");
    //         result = longest(string1.as_str(), string2.as_str());
    //     }
    //     println!("The longest string is {}", result);
    // }

    // 4. 结构体定义中的生命周期注解
    // 这个注解意味着 ImportantExcerpt 的实例不能比其 part 字段中的引用存在的更久。
    struct ImportantExcerpt<'a> {
        part: &'a str,
    }
    impl<'a> ImportantExcerpt<'a> {
        fn level(&self) -> i32 {
            3
        }
        fn announce_and_return_part(&self, announcement: &str) -> &str {
            println!("Attention please: {}", announcement);
            self.part
        }
    }
    {
        let novel = String::from("Call me Ishmael. Some years ago...");
        let first_sentence = novel.split('.')
            .next()
            .expect("Could not find a '.'");
        let i = ImportantExcerpt { part: first_sentence };
    }

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

    fn longest_with_an_announcement<'a, T>(x: &'a str, y: &'a str, ann: T) -> &'a str
        where T: Display
    {
        println!("Announcement! {}", ann);
        if x.len() > y.len() {
            x
        } else {
            y
        }
    }

        fn test1<'a>(arg: &'a i32) -> &'a i32 { arg }
        fn test2<'a, 'b>(arg: &'a i32) -> &'b i32 where 'a: 'b { arg }

pub fn add_two(base: i32) -> i32{
    base + 2
}

// src 内部的一般是单元测试
#[cfg(test)] // 只在执行 cargo test 时才编译和运行测试代码 cargo build 将忽略该模块
mod tests {
    #[test] // 表示当前函数为测试函数
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }

    #[test]
    fn another() {
        panic!("Make this test fail");
    }

    #[test]
    #[should_panic] // 抛出所有异常都将测试通过
    fn should_panic() {
        panic!("应该抛出异常");
    }

    #[test]
    #[should_panic(expected = "应该抛出异常")] // 只期望指定的异常
    fn should_special_panic() {
        panic!("应该抛出异常");
    }

    #[test]
    fn should_fail() {
        assert_ne!(1, 2);
        assert!(true, "测试失败的消息");
        assert_eq!(1, 2, "{} == {} 测试失败", 1, 2);
    }

    #[test]
    fn result() -> Result<(), String> { // 使用Result报告测试结果，如果返回Ok测试通过，返回Err测试失败
        if 2 + 2 == 5 {
            Ok(())
        } else {
            Err(String::from("two plus two does not equal four"))
        }
    }

    #[test]
    #[ignore]  // 忽略该测试
    fn ignore() {
        assert!(true);
    }
}

cargo test  # 运行测试
cargo test --help  # 查看相关参数
cargo test -- --test-threads=1  # 测试二进制文件的测试线程数
cargo test -- --nocapture  # 不显示println! 命令行输出
cargo test it_works  # 运行指定的测试
cargo test should  # 运行指定的测试包含should的测试
cargo test -- --ignored  # 运行`#[ignore]`的测试函数

// test 目录只能测试src/lib.rs中声明的包，不能测试src/main.rs
// use rusttest; // 此种方式也可以
// 声明被测试的外部 crate，就像其他使用该 crate 的程序要声明的那样。
extern crate rusttest;

mod common;


#[test]
fn it_adds_two() {
    common::setup();
    assert_eq!(4, rusttest::add_two(2));
}

pub fn setup() {
    // 编写特定库测试所需的代码
}

cargo test it_adds_two # 运行指定测试
cargo test --test mytest # 运行指定测试文件中的测试

use std::fs;
use std::error::Error;
use std::env;


// 命令行输入结构体
pub struct Config {
    pub query: String,
    pub filename: String,
    pub case_sensitive: bool,
}

impl Config {
    // 构造函数
    pub fn new(args: &[String]) -> Result<Config, &'static str> { // 使用Result包裹返回
        if args.len() < 3 {
            return Err("not enough arguments");
        }

        let query = args[1].clone();
        let filename = args[2].clone();
        let case_sensitive = env::var("CASE_INSENSITIVE").is_err(); // 读取环境变量

        Ok(Config { query, filename, case_sensitive })
    }

    // 使用迭代器的构造函数
    pub fn new1(mut args: std::env::Args) -> Result<Config, &'static str> {
        args.next();

        let query = match args.next() {
            Some(arg) => arg,
            None => return Err("Didn't get a query string"),
        };

        let filename = match args.next() {
            Some(arg) => arg,
            None => return Err("Didn't get a file name"),
        };

        let case_sensitive = env::var("CASE_INSENSITIVE").is_err();

        Ok(Config { query, filename, case_sensitive })
    }
}


pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
    let contents = fs::read_to_string(config.filename)?; // ? 传递出错误

    // println!("With text:\n{}", contents);

    let results = if config.case_sensitive { // 根据是否区分大小写调用函数
        search(&config.query, &contents)
    } else {
        search_case_insensitive(&config.query, &contents)
    };

    for line in results { // 输出结果
        println!("{}", line);
    }

    Ok(())
}

pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> { // 返回结果生命周期与content一致
    // let mut results = Vec::new();
    // // 遍历每一行进行判断
    // for line in contents.lines() {
    //     if line.contains(query) {
    //         results.push(line);
    //     }
    // }

    // results

    // 性能上与上面的实现没有额外损失
    contents.lines()
        .filter(|line| line.contains(query))
        .collect()
}

pub fn search_case_insensitive<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    let query = query.to_lowercase();
    let mut results = Vec::new();

    for line in contents.lines() {
        if line.to_lowercase().contains(&query) {
            results.push(line);
        }
    }

    results
}

// 单元测试： TDD 应该优先实现单元测试函数
#[cfg(test)]
mod tests {
    use super::*;

    // 测试用例：对不区分大消息进行测试
    #[test]
    fn one_result() {
        let query = "duct";
        let contents = "\
Rust:
safe, fast, productive.
Pick three.";

        assert_eq!(
            vec!["safe, fast, productive."],
            search(query, contents)
        );
    }

    #[test]
    fn case_insensitive() {
        let query = "rUsT";
        let contents = "\
Rust:
safe, fast, productive.
Pick three.
Trust me.";

        assert_eq!(
            vec!["Rust:", "Trust me."],
            search_case_insensitive(query, contents)
        );
    }
}

use std::env;
use minigrep::Config;
use std::process;


/**
 * 实现一个类似grep的命令行工具
 */
fn main() {
    // println!("Hello, world!");
    // 读取命令行参数
    let args: Vec<String> = env::args().collect(); // 读取命令行参数
    // println!("{:?}", args);

    // 解析命令行参数
    let config = Config::new(&args).unwrap_or_else(|err| { // 闭包函数处理异常
        eprintln!("Problem parsing arguments: {}", err); // 输出到标准出错流
        process::exit(1);
    });

    // println!("Searching for {}", config.query);
    // println!("In file {}", config.filename);

    // 执行主函数
    if let Err(e) = minigrep::run(config) {
        eprintln!("Application error: {}", e);

        process::exit(1);
    }
}

// 以下结构体/枚举占用的空间为 32 字节（类型标签4字节，最长成员Write(String) 24，内存对齐4字节）
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

    // Rust 结构体内存大小
    println!("Message Size is {}", std::mem::size_of::<Message>());
    println!("String Size is {}", std::mem::size_of::<String>());

// rust 结构体必须能计算出结构体的确定占用内存打下（类似于C的结构体）
// 所以递归类型需要使用Box或者引用

// 以下实现一个函数式的List

enum List {
    // Cons(i32, List), // 报错 recursive type `List` has infinite size
    Cons(i32, Box<List>),
    Nil,
}

use crate::List::{Cons, Nil};

    // Box<T>类型
    println!("List Size is {}", std::mem::size_of::<List>());
    println!("Box<List> Size is {}", std::mem::size_of::<Box<List>>());

    let list = Cons(1,
        Box::new(Cons(2,
            Box::new(Cons(3,
                Box::new(Nil))))));

    // Box 类型实现了Deref特质，所以允许使用 *y 解引用符
    let x = 5;
    let y = Box::new(x);

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

    // Box 类型实现了Deref特质，所以允许使用 *y 解引用符
    let x = 5;
    let y = Box::new(x)

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

struct MyBox<T>(T);

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

use std::ops::Deref;

impl<T> Deref for MyBox<T> {
    type Target = T;

    fn deref(&self) -> &T {
        &self.0
    }
}

    // 自定义结构体实现 Deref特质
    let x = 5;
    let y = MyBox::new(x);

    assert_eq!(5, x);
    assert_eq!(5, *y); // 编译成 *(y.deref())

    fn p(t: &i32) {
        println!("{}", t)
    }
    let ry:&MyBox<i32> = &y;
    p(ry);

fn hello(name: &str) {
    println!("Hello, {}!", name);
}

    let m = MyBox::new(String::from("Rust"));
    // 以下三者等价
    hello(&m); // 效率最高（编译期分析最终引用，直接传递）
    hello(m.deref().deref());
    hello(&(*m)[..]);

// Drop 特质，在超出作用域后执行清理操作
struct CustomSmartPointer {
    data: String,
}

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

    // Drop 特质
    {
        let c = CustomSmartPointer { data: String::from("my stuff") };
        let d = CustomSmartPointer { data: String::from("other stuff") };
        println!("CustomSmartPointers 被创建.");
    }

    // 通过 std::mem::drop 提早丢弃值
    {
        let c = CustomSmartPointer { data: String::from("some data") };
        println!("CustomSmartPointer 被创建");
        // c.drop(); // explicit destructor calls not allowed 不允许显式的析构函数调用
        drop(c); // 本质上就是个空函数 pub fn drop<T>(_x: T) { } 利用所有权转移实现析构😂
        println!("CustomSmartPointer 在这个作用域之前就被Drop了");
    }

// 使用引用计数实现
enum List2 {
    Cons2(i32, Rc<List2>),
    Nil2,
}

use crate::List2::{Cons2, Nil2};

    // 引用计数指针Rc<T> （仅单线程使用、避免循环引用）
    // Box 不支持多个变量持有同一份数据的所有权
    // let a = Cons(5,
    //     Box::new(Cons(10,
    //         Box::new(Nil))));
    // let b = Cons(3, Box::new(a));
    // let c = Cons(4, Box::new(a)); // 报错 use of moved value: `a`
    let a = Rc::new(Cons2(5, Rc::new(Cons2(10, Rc::new(Nil2)))));
    let b = Cons2(3, Rc::clone(&a));
    let c = Cons2(4, Rc::clone(&a));

    {
        let a = Rc::new(Cons2(5, Rc::new(Cons2(10, Rc::new(Nil2)))));
        println!("创建 a 后的引用计数 = {}", Rc::strong_count(&a)); // 1
        let b = Cons2(3, Rc::clone(&a));
        println!("创建 b 后的引用计数 = {}", Rc::strong_count(&a)); // 2
        {
            let c = Cons2(4, Rc::clone(&a));
            println!("创建 c 后的引用计数 = {}", Rc::strong_count(&a)); // 3
        }
        println!("c 离开作用域后的引用计数 = {}", Rc::strong_count(&a)); // 2
    }

// 例子： 测试mock

// 这是待测试对象依赖的外部对象
pub trait Messenger {
    fn send(&self, msg: &str);
}

// 下面是待测试对象：检查消息体大小，如果消息体大小超过阈值，则使用Messenger发送一个消息
pub struct LimitTracker<'a, T: Messenger> {
    messenger: &'a T,
    value: usize,
    max: usize,
}

impl<'a, T> LimitTracker<'a, T>
    where T: Messenger {
    pub fn new(messenger: &T, max: usize) -> LimitTracker<T> {
        LimitTracker {
            messenger,
            value: 0,
            max,
        }
    }

    pub fn set_value(&mut self, value: usize) {
        self.value = value;

        let percentage_of_max = self.value as f64 / self.max as f64;

        if percentage_of_max >= 1.0 {
            self.messenger.send("Error: You are over your quota!");
        } else if percentage_of_max >= 0.9 {
             self.messenger.send("Urgent warning: You've used up over 90% of your quota!");
        } else if percentage_of_max >= 0.75 {
            self.messenger.send("Warning: You've used up over 75% of your quota!");
        }
    }
}

// 下面是一个Messenger的Mock实现

#[cfg(test)]
mod tests {
    use super::*;
    use std::cell::RefCell;

    struct MockMessenger {
        // sent_messages: Vec<String>, // 此种方案将报错
        sent_messages: RefCell<Vec<String>>,
    }

    impl MockMessenger {
        fn new() -> MockMessenger {
            MockMessenger { sent_messages: RefCell::new(vec![]) }
        }
    }

    impl Messenger for MockMessenger {
        fn send(&self, message: &str) {
            // self.sent_messages.push(String::from(message));  // 使用sent_messages: Vec<String>, 将报错 cannot borrow `self.sent_messages` as mutable, as it is behind a `&` reference(E0596)
            // 解决方案1：（不推荐）修改send方法的&self为&mut self（需要修改特质声明和调用者）
            // 解决方案2：使用 RefCell<T> 保证对外不可变，对内可变，如下
            self.sent_messages.borrow_mut().push(String::from(message));
        }
    }

    #[test]
    fn it_sends_an_over_75_percent_warning_message() {
        let mock_messenger = MockMessenger::new();
        let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);

        limit_tracker.set_value(80);

        assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
    }

}

    // RefCell<T> 在运行时检查借用规则，必须满足借用规则
    {
        let sent_messages:RefCell<Vec<String>> = RefCell::new(vec![]);
        let mut one_borrow = sent_messages.borrow_mut();
        // let mut two_borrow = sent_messages.borrow_mut(); // 编译不报错，运行时触发panic，因为违反了只有一个可变引用 already borrowed: BorrowMutError

        one_borrow.push(String::from("a"));
        // two_borrow.push(String::from("b"));
    }
    {
        // 同样不能同时借出可变和不可变引用
        let sent_messages:RefCell<Vec<String>> = RefCell::new(vec![]);
        let mut one_borrow = sent_messages.borrow_mut();
        // let mut two_borrow = sent_messages.borrow(); // 编译不报错，运行时触发panic，因为已经借出不可便引用了 already mutably borrowed: BorrowError

        one_borrow.push(String::from("a"));
        // println!("{}", two_borrow.len());
    }

use std::rc::Rc;
use std::cell::RefCell;

#[derive(Debug)]
enum List3 {
    Cons3(Rc<RefCell<i32>>, Rc<List3>),
    Nil3,
}

use crate::List3::{Cons3, Nil3};

    // 结合 Rc<T> 和 RefCell<T> 来拥有多个可变数据所有者
    // 实现拥有可变List
    {
        let value = Rc::new(RefCell::new(5));

        let a = Rc::new(Cons3(Rc::clone(&value), Rc::new(Nil3)));

        let b = Cons3(Rc::new(RefCell::new(6)), Rc::clone(&a));
        let c = Cons3(Rc::new(RefCell::new(10)), Rc::clone(&a));

        *value.borrow_mut() += 10;

        println!("a after = {:?}", a);
        println!("b after = {:?}", b);
        println!("c after = {:?}", c);
    }

#[derive(Debug)]
enum List4 {
    Cons4(i32, RefCell<Rc<List4>>),
    Nil4,
}

use crate::List4::{Cons4, Nil4};

impl List4 {
    fn tail(&self) -> Option<&RefCell<Rc<List4>>> {
        match self {
            Cons4(_, item) => Some(item),
            Nil4 => None,
        }
    }
}

    {
        // 制造一个循环引用导致的内存泄漏
        // a = (5, nil)
        let a = Rc::new(Cons4(5, RefCell::new(Rc::new(Nil4))));

        println!("a 初始化引用计数 = {}", Rc::strong_count(&a));
        println!("a 的 tail = {:?}", a.tail());

        // b = (10, a)
        let b = Rc::new(Cons4(10, RefCell::new(Rc::clone(&a))));

        println!("a 在 b 创建后的引用计数 = {}", Rc::strong_count(&a));
        println!("b 初始化引用计数 = {}", Rc::strong_count(&b));
        println!("b 的 tail = {:?}", b.tail());

        // a = (5, b)
        if let Some(link) = a.tail() {
            *link.borrow_mut() = Rc::clone(&b);
        }

        println!("改变 a 的 tail 为 b 后, b 的引用计数 = {}", Rc::strong_count(&b));
        println!("改变 a 的 tail 为 b 后, a 的引用计数 = {}", Rc::strong_count(&a));

        // Uncomment the next line to see that we have a cycle;
        // it will overflow the stack
        // println!("a next item = {:?}", a.tail());
    }

use std::rc::Rc;
use std::rc::Weak;

fn test_rc_weak() -> Weak<i32> {
    let rc1 = Rc::new(3);
    let rc2 = rc1.clone();
    let weak1 = Rc::downgrade(&rc1);
    println!(
            "leaf strong = {}, weak = {}",
            Rc::strong_count(&rc1),
            Rc::weak_count(&rc1),  // 0
    );
    weak1
}

fn main() {
    let weak1 = test_rc_weak();
    println!("{:?}", weak1.upgrade());
}

// 双向链表类似的结构的实现使用弱引用防止循环引
// 例子：树结构，节点持有所有孩子的引用和指向父亲的引用

#[derive(Debug)]
struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>, // 指向父亲的弱引用（不持有所有权，通过Rc::downgrade创建，Rc<T> 类型使用 weak_count 来记录其存在多少个 Weak<T> 引用）
    children: RefCell<Vec<Rc<Node>>>,
}

    {
        // 弱引用应用样例
        // 创建叶子
        let leaf = Rc::new(Node {
            value: 3,
            parent: RefCell::new(Weak::new()),
            children: RefCell::new(vec![]),
        });

        println!("leaf 的 父亲 = {:?}", leaf.parent.borrow().upgrade());

        // 创建父节点
        let branch = Rc::new(Node {
            value: 5,
            parent: RefCell::new(Weak::new()),
            children: RefCell::new(vec![Rc::clone(&leaf)]),
        });

        // 叶子节点的 parent 引用指向 父亲
        *leaf.parent.borrow_mut() = Rc::downgrade(&branch);

        println!("leaf 的 父亲 = {:?}", leaf.parent.borrow().upgrade());
    }

    {
        // 查看 Rc 内部 强引用 strong_count 和 弱引用 weak_count 的值
        let leaf = Rc::new(Node {
            value: 3,
            parent: RefCell::new(Weak::new()),
            children: RefCell::new(vec![]),
        });

        println!(
            "leaf strong = {}, weak = {}",
            Rc::strong_count(&leaf), // 1
            Rc::weak_count(&leaf),  // 0
        );

        {
            let branch = Rc::new(Node {
                value: 5,
                parent: RefCell::new(Weak::new()),
                children: RefCell::new(vec![Rc::clone(&leaf)]),
            });

            *leaf.parent.borrow_mut() = Rc::downgrade(&branch);

            println!(
                "branch strong = {}, weak = {}",
                Rc::strong_count(&branch), // 1
                Rc::weak_count(&branch), // 1
            );

            println!(
                "leaf strong = {}, weak = {}",
                Rc::strong_count(&leaf), // 2
                Rc::weak_count(&leaf), // 0
            );
        } // branch.strong_count == 0, branch.T 被回收，

        println!("leaf parent = {:?}", leaf.parent.borrow().upgrade()); // 父亲已经被回收, 返回 None（is_dangling(branch.ptr) 已经悬空了）
        println!(
            "leaf strong = {}, weak = {}",
            Rc::strong_count(&leaf), // 1
            Rc::weak_count(&leaf), // 0
        );
    }

use std::thread;
use std::time::Duration;

fn main() {
    // 创建新线程
    // 为了减小运行时，rust 线程与 操作系统线程 1:1 关系
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("子线程 {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("主线程 {}", i);
        thread::sleep(Duration::from_millis(1));
    }
    // 默认主线程结束后子线程也自动结束
    // 使用join等待子线程结束
    handle.join().unwrap();

    // 线程闭包
    {
        let v = vec![1, 2, 3];

        let handle = thread::spawn(move || { // 不适用move将报错，因为编译器推断出是引用
            println!("闭包环境v = {:?}", v);
        });

        // println!("{:?}", v); // 上边 move 作用 是 将 闭包 捕获到的变量 移动到 内部，原理应该是 构建匿名结构体时类型不为引用

        handle.join().unwrap();
    }
}

use std::thread;
use std::time::Duration;
use std::sync::mpsc;


fn main() {
    // 类似Go语言消息通道
    {
        // let (tx, rx) = mpsc::channel::<String>();
        let (tx, rx) = mpsc::channel();
        let tx2 = mpsc::Sender::clone(&tx); // 通过clone创建多个发送者
        // tx 和 rx 通常作为 发送者（transmitter）和 接收者（receiver）的缩写

        // 子线程1发送消息
        thread::spawn(move || {
            let val = String::from("hi");
            // 调用时 rx 没有被 drop 则返回OK，否则返回Err
            tx.send(val).unwrap();

             let vals = vec![
                String::from("hi"),
                String::from("from"),
                String::from("the"),
                String::from("thread"),
            ];

            for val in vals {
                tx.send(val).unwrap();
                thread::sleep(Duration::from_secs(1));
            }
        });

        // 子线程2发送消息
        thread::spawn(move || {
            let vals = vec![
                String::from("more"),
                String::from("messages"),
                String::from("for"),
                String::from("you"),
            ];

            for val in vals {
                tx2.send(val).unwrap();
                thread::sleep(Duration::from_secs(1));
            }
        });
        // 阻塞直到收到消息
        let received = rx.recv().unwrap();
        println!("收到消息: {}", received);
        // 迭代器接收消息
        for received in rx.iter() { // 当通道关闭不迭代器返回
            println!("迭代器方式: {}", received);
        }
        // 立即返回
        match rx.try_recv() {
            Ok(m) => println!("try_recv 收到消息: {}", m),
            Err(e) => println!("try_recv 异常 {:?}", e),
        };
    }
}

use std::thread;
use std::time::Duration;
use std::sync::mpsc;
use std::sync::{Mutex, Arc};


fn main() {
    // 共享状态

    // 创建一个锁（这个锁持有一个共享变量）
    let m = Mutex::new(5); // 提供了内部可变性
    // Rust 编译器不能避免死锁

    {
        // lock 获取锁，如果被其他进程持有，将阻塞
        // unwrap 获取锁持有变量的智能指针
        let mut num = m.lock().unwrap();
        *num = 6; // 修改共享变量的值
    }

    println!("m = {:?}", m);

    // 多线程共享状态
    // let counter = Mutex::new(0); //直接使用counter报错，因为所有权没移动了多次
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter); // 创建线程安全引用计数
        let handle = thread::spawn(move || {
            // 使用线程安全引用计数
            let mut num = counter.lock().unwrap();

            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("多线程共享变量值: {}", *counter.lock().unwrap());

}

pub struct AveragedCollection {
    list: Vec<i32>,
    average: f64,
}

impl AveragedCollection {
    pub fn add(&mut self, value: i32) {
        self.list.push(value);
        self.update_average();
    }

    pub fn remove(&mut self) -> Option<i32> {
        let result = self.list.pop();
        match result {
            Some(value) => {
                self.update_average();
                Some(value)
            },
            None => None,
        }
    }

    pub fn average(&self) -> f64 {
        self.average
    }

    fn update_average(&mut self) {
        let total: i32 = self.list.iter().sum();
        self.average = total as f64 / self.list.len() as f64;
    }
}

trait MyTrait {
    fn defaultMethod(&self){
        println!("Default Impl");
    }
}

struct MyStruct {}

impl MyTrait for MyStruct {}

    let myStruct = MyStruct{};
    myStruct.defaultMethod();

通过 trait 和 dyn 关键字实现

// 通用方法抽象为Trait
// 本例中为 GUI中通用方法 draw 绘制
pub trait Draw {
    fn draw(&self);
}

// 屏幕持有持有实现了Draw特质的Vec
pub struct Screen {
    pub components: Vec<Box<dyn Draw>>, // Trait对象: 这种方式允许存放异质元素，会带来额外的运行时负担，实现上类似Java类型擦除
    // Trait 对象安全限制，只允许对象安全的Trait使用 dyn 修饰 规则如下两条
    // 返回值类型不为 Self
    // 方法没有任何泛型类型参数
    // （因为运行时类型擦除，返回Self类型，但是运行时并不知道Self和泛型是什么）
}

// screen 有一个 run 方法 调用 draw
impl Screen {
    pub fn run(&self) {
        for component in self.components.iter() {
            component.draw();
        }
    }
}

// 实现Draw子类
// 模拟一个Button
pub struct Button {
    pub width: u32,
    pub height: u32,
    pub label: String,
}

impl Draw for Button {
    fn draw(&self) {
        // 实际绘制按钮的代码
        println!("Button")
    }
}

// 模拟一个选择器
struct SelectBox {
    width: u32,
    height: u32,
    options: Vec<String>,
}

impl Draw for SelectBox {
    fn draw(&self) {
        // code to actually draw a select box
        println!("SelectBox");
    }
}

// 以下这种方式不允许，因为编译后具象化出来了
// pub struct Screen<T: Draw> {
//     pub components: Vec<T>,
// }

// impl<T> Screen<T>
//     where T: Draw {
//     pub fn run(&self) {
//         for component in self.components.iter() {
//             component.draw();
//         }
//     }
// }

    let screen = Screen {
        components: vec![
            Box::new(SelectBox {
                width: 75,
                height: 10,
                options: vec![
                    String::from("Yes"),
                    String::from("Maybe"),
                    String::from("No")
                ],
            }),
            Box::new(Button {
                width: 50,
                height: 10,
                label: String::from("OK"),
            }),
        ],
    };

    screen.run();

    {
        let mut num = 5;
        // 创建裸指针不需要使用unsafe包裹
        let r1 = &num as *const i32; // 通过as强转为裸指针
        println!("addr={:x}", r1 as usize);
        let r2 = &mut num as *mut i32;
        println!("addr={:x}", r2 as usize);
    }

    {
        let address = 0x012345usize;
        let r = address as *const i32;
        println!("addr={:x}", r as usize);
    }

    {
        let mut num = 5;

        let r1 = &num as *const i32;
        let r2 = &mut num as *mut i32;

        unsafe {
            println!("r1 is: {}", *r1);
            println!("r2 is: {}", *r2);
        }
    }

    {
        unsafe fn dangerous() {
            println!("unsafe function")
        }
        // dangerous(); //报错 call to unsafe function is unsafe and requires unsafe function or block
        unsafe {
            dangerous();
        }
    }

    // 例子：模拟实现 split_at_mut
    {
        // 将一个Vec的切片一分为两个
        let mut v = vec![1, 2, 3, 4, 5, 6];

        let r = &mut v[..];

        let (a, b) = r.split_at_mut(3); // 切分函数

        assert_eq!(a, &mut [1, 2, 3]);
        assert_eq!(b, &mut [4, 5, 6]);

        // 模拟实现
        use std::slice;
        fn split_at_mut(slice: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
            let len = slice.len();
            let ptr = slice.as_mut_ptr(); // 获取裸指针

            assert!(mid <= len);

            unsafe { // 调用不安全的实现
                (slice::from_raw_parts_mut(ptr, mid),
                slice::from_raw_parts_mut(ptr.offset(mid as isize), len - mid))
            }
        }
        let (a, b) = split_at_mut(r, 3); // 切分函数
        assert_eq!(a, &mut [1, 2, 3]);
        assert_eq!(b, &mut [4, 5, 6]);
    }

    // 使用 extern 函数调用外部代码（c语言函数）
    {
        extern "C" {
            fn abs(input: i32) -> i32;
        }
        unsafe {
            println!("Absolute value of -3 according to C: {}", abs(-3));
        }
    }

#[no_mangle] //还需增加 #[no_mangle] 注解来告诉 Rust 编译器不要 mangle 此函数的名称
pub extern "C" fn call_from_c() { // extern 的使用无需 unsafe。
    println!("Just called a Rust function from C!");
}

    {
        // 实例参考 Searcher
        unsafe trait Foo {
            // methods go here
            fn test(&self);
        }

        unsafe impl Foo for i32 { // 约束在这，实现者必须也使用unsafe标记
            // method implementations go here
            fn test(&self){
                let ptr = self as *const i32;
                unsafe { println!("unsafe trait value={}", *ptr) };
            }
        }
        let i:i32 = 1;
        i.test();
    }

    {
        // 带有关联类型的特质
        pub trait MyTrait {
            type A; // 在一个特质中使用type关键字定义，一般作为函数返回值（每一个实现者只需要指定一次，会出现指定多次）
            type B; // 可以定义多个

            fn get_a_option(&self, a: Self::A) -> Option<Self::A>;
            fn get_b_option(&self, b: Self::B) -> Option<Self::B>;
        }
        // 实现带有关联类型的特质
        pub struct MyStruct {}
        impl MyTrait for MyStruct {
            type A = i32;
            type B = &'static str;

            fn get_a_option(&self, a: Self::A) -> Option<Self::A> {
                println!("a = {}", a);
                Some(a)
            }
            fn get_b_option(&self, b: Self::B) -> Option<Self::B> {
                println!("b = {}", b);
                Some(b)
            }
        }
        let s = MyStruct{};
        s.get_a_option(1);
        let b_o = s.get_b_option("str");
        println!("{:?}", b_o);
        // 为什么不使用泛型<T>，因为泛型的话在调用的时候需要手动指定类型，对调用方不友好
        // 例子如下
        pub trait MyTrait2<T> {
            fn get_t_option(&self) -> Option<T>;
        }
        pub struct MyStruct2 {};
        impl MyTrait2<i32> for MyStruct2 {
            fn get_t_option(&self) -> Option<i32>{
                Some(1)
            }
        }
        impl MyTrait2<&'static str> for MyStruct2 {
            fn get_t_option(&self) -> Option<&'static str>{
                Some("str")
            }
        }
        let s2 = MyStruct2{};
        println!("{:?}", s2.get_t_option() as Option<i32>); // 调用时需要明确类型
        let o2:Option<&str> = s2.get_t_option();  // 调用时需要明确类型
        println!("{:?}",o2);
    }