《Rust权威指南》笔记

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

// 标准库中定义的比较结果的枚举
use std::cmp::Ordering;
// 使用use语句进行包导入；rust默认会预导入(prelude)一部分常用的类型，而std::io不在此范围，需要使用use语句
use std::io;

// 首先使用了rand包，需要在Cargo.toml中添加rand = "0.8.0"
// 在run或者build的时候，会根据crates.io上的最新版本、依赖关系下载所需要的包
// rand::Rng为trait(后面解析)，gen_range定义于此Trait中
// 如果不导入，调用gen_range将报错，因为ThreadRng的对应实现定义于Rng trait中
use rand::Rng;

fn main() {
    // rand::thread_rng()将返回位于本地线程空间的随机数生成器ThreadRng，实现了rand::Rng这一trait
    // gen_range的参数签名在0.7.0的包和0.8.x的包上不一样，在旧版中支持两个参数，而新版本中只支持一个参数
    // 1..101的用法后面介绍，这一行表示生成[1,101)的随机数
    let secret_num = rand::thread_rng().gen_range(1..101);
    println!("secret number is {}", secret_num);

    // 死循环
    loop {
        // let关键字用于创建变量
        // 默认变量都是不可变的，使用mut关键字修饰可以使变量可变
        // String是标准库中的字符串类型，内部我问个他UTF-8编码并可动态扩展
        // new是String的一个关联函数(静态方法)，用于创建一个空的字段串
        let mut guess = String::new();

        println!("Guess the number!\nPlease input your guess:");

        // std::io::stdin()会返回标准输入的句柄
        // 参数&mut guess表示read_line接收一个可变字符串的引用(后面介绍)，将读取到的值存入其中
        // read_line返回io::Result枚举类型，有Ok和Err两个变体(枚举类型的值列表称为变体)
        // 返回Ok时表示正常并通过expect提取附带的值(字节数)；返回Err时expect将中断程序，并将参数显示出来
        // 不带expect时也能通过编译，但会收到Result没有被处理的警告(warning: unused `Result` that must be used)
        io::stdin().read_line(&mut guess).expect("Failed to read line");

        // Rust中允许使用同名新变量来隐藏(shadow)旧值
        // guess:u32是明确guess的类型，以此来使得让编译器推到出parse要返回包含u32的值
        // parse的返回值是一个Result枚举，有Ok和Err两个变体(枚举值)，用match来判断两种情况
        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(e) => {
                println!("Please type a number!");
                // continue回到loop开头继续
                continue;
            }
        };

        // {}为println!的占位符，第1个花括号表示格式化字符串后的第一个参数的值，以此类推
        println!("You guessed:{}", guess);

        // 模式匹配，由match表达式和多个分支组成，Rust可以保证使用match时不会漏掉任何一种情况
        // Rust会将secret_num也推导成u32与guess比较
        match guess.cmp(&secret_num) {
            Ordering::Less => println!("Too small!"),
            Ordering::Equal => {
                println!("You WIN!");
                // 退出循环
                break;
            }
            Ordering::Greater => { println!("Too big!") }
        }
    }
}

    let x: i32;
    x = 5;
    let y: i32 = 10;
    // 以下行报错：Cannot assign twice to immutable variable [E0384]
    // y=9

    let mut x = 10;
    x = 100;
    x = 1000;

const MAX_SCORE: i32 = 199;
fn main() {
    // some other code 
    const MY_SCORE: i32 = 200;
    const MAX_SCORE: i32 = 299;

    // 200,299
    println!("{},{} ", MY_SCORE, MAX_SCORE);
}

    let space = "   ";
    let space = space.len();

    // 以下报错：type annotations needed
    // let k = ("32").parse().expect("not ok");
    let k: i32 = ("32").parse().expect("not ok");

    // 整数类型字面量
    // 10进制，可以用下划分分隔
    let x: u32 = 98_000;
    let x: u32 = 0xff; // 十六进制
    let x: u32 = 0o77; // 八进制
    let x: u32 = 0b1111_0000; // 二进制
    let x = b'A'; // u8

    // 整数溢出
    let x: u8 = 252;
    let y: u8 =  ("32").parse().expect("not ok");
    // 以下行在debug模式下，会在运行时报错
    // thread 'main' panicked at 'attempt to add with overflow', src/main.rs:41:26
    // note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
    // 在release模式下，则不会报错，输出28
    println!("{},see!", x + y);

    // 类型不一样，无法操作
    // let x:u8 = 10;
    // let y:u32 = 100;
    // let z = y+x;

    let x:bool = false;

    // 字符类型
    let x = 'c';
    let y = '李';
    let z:char = '李';

    // 元组
    // 也可以省略类型，让编译器推断
    let x:(i64,f64,char) = (2,3.4, 'c');
    // 使用模式匹配来解构元组
    let (a,b,c) = x;
    // 通过点来访问元组
    println!("{},{},{}", x.0, x.1, x.2);

    // 数组
    // 声明一个长度为5，元素为int32类型的数组；类型[i32;5]也可以省略，由编译器推断
    let x: [i32; 5] = [1, 2, 3, 4, 5];
    // 定义了一个由7个1组成的数组，即[1,1,1,1,1,1,1]
    let y = [1; 7];
    // 通过下标来访问，从0开始；以下输出3,1；下标的类型是usize的
    println!("{},{}", x[2], y[6]);
    // 越界时将发生严重错误
    // 编译时报错：index out of bounds: the length is 5 but the index is 10
    // 如果下标是运行时才确定的值，则这块的报错将在运行时报错
    // let k:usize = "10".parse().expect("not a number");
    // println!("{}", x[k]);

fn my_sum(x: i32, y: i32) -> i32 {
    // 可以直接是return，也可以直接写表达式x+y，函数中将最后一个表达式的值做为返回值
    return x + y;
}

    // 语句，没有返回值
    let x = 6;
    // 所以不能将语句赋值给变量
    // let y = (let x = 7);
    // 以下也不行
    // let a = b = 6;
    // 花括号的代码块也是表达式，以下表达式的值为11
    let x = {
      let y = 10;
        // 注意这一行不能有分号，添加了分号后，这个代码块的值就是空元组了()
        y+1
    };

    // if的用法，多分支判断，条件表达式的值只能是bool类型
    let num = 100;
    if num % 4 == 0 {
        println!("number is divisible by 4")
    } else if num % 3 == 0 {
        println!("number is divisible by 3")
    } else {
        println!("number is not divisible by 3,4")
    }

    // if为表达式，所以可以使用if来赋值
    // 此处要注意各个分支返回的数据类型要一样，否则编译期直接报错
    let condition = true;
    let x = if condition {
        10
    }else {
        20
    };

  // loop表达式的值，可以从break返回
    let mut i = 1;
    let count = loop{
        i+=1;
        if i > 10 {
            break i
        }
        // 两个break的值类型要一样，所以以下这一行无法通过编译
        // break 'a'
    };

    // while表达式的值一直是空值，如果使用break，后面不能跟返回值
    let mut i = 1;
    let count:() = while i > 10 {
        i += 1;
    };

    // y是一个Range<i32>类型，本身是一个迭代器；值为1,2(不包括3)
    // rev是从后往前遍历，所以这块打印的是2,1,
    let y = 1..3;
    for e in y.rev() {
        print!("{},", e)
    }

// 摄氏温度与华氏温度的相互转换
// println!("celsius_2_fahrenheit(1):expect{}, actual:{}", 33.8, celsius_2_fahrenheit(1.0));
fn celsius_2_fahrenheit(celsius: f64) -> f64 {
    celsius * 1.8 + 32.0
}

// 生成一个n阶的斐波那契数列
// println!("fibonacci(10):expect{}, actual:{}", 34, fibonacci(10));
fn fibonacci(n: i64) -> i64 {
    if n == 1 {
        0
    } else if n == 2 {
        1
    } else {
        fibonacci(n - 1) + fibonacci(n - 2)
    }
}

// 打印圣诞颂歌The Twelve Days of Christmas的歌词，并利用循环处理其中重复的内容。
// 太长了，改成The Six Days of Christmas
// the_six_days_of_christmas();
fn the_six_days_of_christmas() {
    let num_map = ["first", "second", "third", "forth", "fifth", "sixth"];
    let gifts = ["a partridge in a pear tree",
        "two turtle doves",
        "three French hens",
        "four calling birds",
        "five golden rings",
        "six geese a-laying",
    ];

    for i in 0..6 {
        print!("On the {} day of Christmas, my true love sent to me:", num_map[i]);
        let mut j = i;
        while j > 0 {
            print!("{},", gifts[j]);
            j -= 1;
        }
        // 最后一个礼物不需要逗号
        println!("{}.", gifts[0]);
    }
}

    // 字符串类型在堆上分配
    // String::from方法，使用字符串字面量来创建String类型，这里s必须是可变的
    let mut s = String::from("Hello");
    s.push_str(", world");
    println!("{}", s)

    let s1 = String::from("Hello");
    let s2 = s1;
    println!("{}", s1)

    // 对s1进行深拷贝，即将堆上的内容也进行了拷贝
    let s1 = String::from("Hello");
    let s2 = s1.clone();
    println!("{}, {}", s1, s2);

    // 如果这个元组加了String类型，如下，则不能通过编译
    let x = (1,2,3.0);
    // let x = (1, 2, 3.0, String::from("Hello"));
    let y = x;
    println!("{}", x.1);

    let x = [1, 2, 3];
    let y = x;
    println!("{}", x[1]);

    fn take_owner(s: String) {}
    let s = String::from("hello");
    take_owner(s);
    // 将发生编译错误，因为s的所有权移进了take_owner中
    // println!("{}", s);

    fn take_owner_and_return(s: String)->String{
        // 函数又将s的所有权转移到返回值，所以s不会被drop掉
        return s;
    }
    let s1 = String::from("hellow");
    let s2 = s1;// 到这里，s1已经失效
    let s3 = take_owner_and_return(s2); // 到这里s2已经失效
    // 这里只有s3可用，其它的s1,s2失效

    // 引用传递时，并不取得所有权，但可以使用值
    fn get_len(s: &String) -> usize {
        // s是一个不可变引用，所以无法对s的值进行改变
        // 以下无法通过编译
        // s.push_str(", world");
        return s.len();
    }
    let s1 = String::from("hello");
    // s2为可变引用，默认的引用不可变
    let mut s2: &String = &s1;
    let mut s3 = String::from("hello");
    // 注意s2为可变引用的意思是可以改变s2引用到哪个值，而不能改变s2引用的值
    // 以下无法通过编译， 报错: cannot borrow `*s2` as mutable, as it is behind a `&` reference
    // s2.push_str(", world");
    // 因为两行可以运行，因为s2是可变引用，而且s3是可变String
    s2 = &mut s3;
    // 虽然s2引用了可变的s3，但由于s2的类型是&String不是&mut String，所以到下这一行还是无法通过编译
    // s2.push_str(", world");
    // 获取s1的长度，而不取得s1的所有权
    let size = get_len(&s1);
    {
        let s4 = String::from("you");
        // 由于s4的生命周期比s2短，所以s2无法引用s4，这避免了悬垂指针的出现
        // s2 = &s4;
    }
    // 在这里s1还是能用
    println!("{},{},{},{}", s1, s2, size, s1);

    let mut s:String = String::from("hello");
    let s1:&mut String = &mut s;
    s1.push_str(",world");

    let mut s:String = String::from("hello");
    let mut s2:&String = &mut s;
    // 以下无法通过编译，因为s2是&String不可变类型
    s2.push_str(", world");

    let mut s = String::from("hello");
    let s1 = &mut s;
    // cannot borrow `s` as mutable more than once at a time
    // let s2 = &mut s;
    // cannot borrow `s` as immutable because it is also borrowed as mutable
    // let s3 = &s;
    println!("{},{}, {}", s1, s2, s3);

    // 字符串切片，类似与go，获取[begin,end)之间的内容，注意end最大是字符串的长度，超过后会报错
    let s = String::from("0123456789");
    // 以下两个hello和world等价
    let hello = &s[0..5];
    let hello: &str = &s[..5];
    let world = &s[5..10];
    let world = &s[5..];
    // 01234,56789
    println!("{},{}", hello, world);

    // 获取第一个单词，返回字符串切片
    // 这里的函数参数也可以使用&str，可以更通用
    fn first_world(s: &String) -> &str {
        // s.as_bytes()将字符串转成字节数组&[u8]
        // iter返回迭代器，enumerate将每一个元素按元组的形式返回
        for (i, &item) in s.as_bytes().iter().enumerate() {
            // 判断是空格，直接返回切片
            if item == b' ' {
                return &s[0..i];
            }
        }
        &s[..] // 使用&s也可以
    }
    // 输出hello
    println!("{}", first_world(&String::from("hello world")));

    let mut s = String::from("0123456789");
    let t = first_world(&s);
    // 以下无法通过编译，因为s已经是不可变引用了，s.clear又使用了可变引用
    // cannot borrow `s` as mutable because it is also borrowed as immutable
    // s.clear();
    println!("{},{}", s, t);

    // 其它切片
    let ia = [1, 2, 3, 4, 5, 6];
    let sia: &[i32] = &ia[1..3];

    // 结构体定义
    struct User {
        username: String,
        email: String,
        sign_in_count: u64,
        active: bool,
    }
    // 创建实例
    let mut user1 = User {
        username: String::from("xiaochai"),
        email: "soso2501@mgail.comxxx".to_string(),
        sign_in_count: 1,
        active: true,
    };
    println!("{}", user1.email); // soso2501@mgail.comxxx
    // 访问和修改，注意一旦实例可变，则实例的所有成员都可变
    user1.email = String::from("soso2501@mgail.com");
    println!("{}", user1.email); // soso2501@mgail.com

    fn build_user(email: String, username: String) -> User {
        User {
            username, // 由于变量名了字段同名，所以可以省略掉字段名
            email,
            sign_in_count: 1,
            active: true,
        }
    }
    let mut user1 = build_user("soso2501@mgail.com".to_string(), "xiaochai".to_string());
    let mut user2 = User {
        username: "xiaochai2".to_string(),
        // 可以使用以下语法从user1复制剩下的字段
        ..user1
    };
    user1.email = "sosoxm@163.com".to_string();
    // soso2501@mgail.com,sosoxm@163.com
    println!("{},{}", user2.email, user1.email);

    // 元组结构体
    // 当成员变量没有名字时，结构体与元组类似，称为元组结构体
    struct Point(u32, u32, u32);
    let origin = Point(0, 0, 0);
    // 可以使用数字下标来访问
    println!("{},{},{}", origin.0, origin.1, origin.2);
    // 也可以通过模式匹配来结构
    let Point(x, y, z) = origin;
    println!("{},{},{}", x, y, z);

    // 空结构体，一般用于trait
    struct Empty{}

    // 如果结构体的成员是引用时，需要带上生命周期的标识
    struct User2<'a> {
        username: &'a str,
    }

    // 使用结构的例子，说明trait的使用
    #[derive(Debug)] // 添加注解来派生Debug trait
    struct Rectangle {
        width: u32,
        height: u32,
    }
    fn area(rect: &Rectangle) -> u32 {
        rect.width * rect.height
    }
    let rect1 = Rectangle { width: 10, height: 20 };
    // {:?}需要结构体实现Debug这一trait，也可以使用{:#?}来分行打印
    // the area of rectangle Rectangle { width: 10, height: 20 } is 200
    println!("the area of rectangle {:?} is {}", rect1, area(&rect1))

    // 为结构体定义方法
    impl Rectangle {
        // 方法的第一个参数永远是self
        fn area(&self) -> u32 {
            self.height * self.width
        }
    }
    println!("the area of rectangle {:?} is {}", rect1, rect1.area());

    impl Rectangle {
        // 以下无法通过编译，因为area重复定义了
        // fn area(&self, i: i32) -> u32 {
        //     self.height * self.width
        // }
        fn can_hold(&self, rect2: &Rectangle) -> bool {
            self.width > rect2.width && self.height > rect2.height
        }
        // 关联函数
        fn new(width: u32, height: u32) -> Rectangle {
            Rectangle {
                width,
                height,
            }
        }
    }
    println!("the area of rectangle {:?} is {}", Rectangle::new(3, 2), Rectangle::new(2, 3).area());

    enum IPAddr {
        // 变体中可以保存数值
        IPV4(u32, u32, u32, u32),
        IPV6(String),
    }
    // 可以为枚举定义函数
    impl IPAddr {
        fn print(&self) {
            // 使用match来处理每一种变体，注意需要处理所有变体，否则编译保险错
            match self {
                // 模式匹配可以直接解构变体内的数值
                IPAddr::IPV4(u1, u2, u3, u4) =>
                    println!("{}.{}.{}.{}", u1, u2, u3, u4),
                IPAddr::IPV6(s) => println!("{}", s),
            }
        }
    }
    let ipv4 = IPAddr::IPV4(1, 2, 3, 4);
    let ipv6 = IPAddr::IPV6("::1".to_string());
    ipv4.print();
    ipv6.print();

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

    // 标准库中的Option类型
    // 为一个Option值加1
    fn plus_one(c: Option<i32>) -> Option<i32> {
        match c {
            None => None,
            Some(i) => Some(i + 1)
        }
    }
    let five = plus_one(Some(4));
    let none = plus_one(None);
    match five {
        None => println!("none"),
        Some(i) => println!("val is {}", i)
    };
    match none {
        None => println!("none"),
        Some(i) => println!("val is {}", i)
    };

    // 必须匹配每一个可能的值
    let c = 2;
    match c {
        1 => println!("is 1"),
        2 => println!("is 2"),
        // 如果没有以下这一行，则编译报错
        // non-exhaustive patterns: `i32::MIN..=0_i32` and `3_i32..=i32::MAX` not covered
        _ => println!("other")
    }

    // 使用if let来简化处理
    let five: Option<i32> = Some(5);
    if let Some(i) = five {
        println!("has value {}", i)
    }

// 定义模块，可以嵌套子模块
mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}

        pub fn seat_at_table() {}
    }

    pub mod serving {
        fn take_order() {}

        fn serve_order() {}

        fn take_payment() {}

        mod back_of_house {
            fn fix_incorrect_order() {
                // 使用super关键字引用父模块的，由于子模块可以使用父模块的所有条目，包括私有
                super::serve_order();
                cook_order();
            }

            fn cook_order() {}

            pub struct Breakfast {
                pub toast: String,
                // 虽然结构体是公有的，但字段默认还是私有的，需要用pub指定
                season_fruit: String,
            }

            impl Breakfast {
                pub fn summer(toast: &str) -> Breakfast {
                    Breakfast {
                        toast: String::from(toast),
                        season_fruit: String::from("peaches"),
                    }
                }
            }

            pub enum Appetizer {
                // 以下两个变体是公开的
                Soup,
                Salad,
            }
        }
    }
}

pub fn eat_at_restaurant() {
    // 以下两种调用是等价的
    // 使用绝对路径，从crate关键字（即根节点）开始
    crate::front_of_house::hosting::add_to_waitlist();
    // 使用相对路径，从当前模块开始
    front_of_house::hosting::add_to_waitlist();
}

// 使用use关键字可以简化路径
// 以下两行等价，self关键字可能在后续版本中去掉
use front_of_house::hosting;
// use self::front_of_house::hosting;

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

// 为防止重名，使用as来重命名
use std::fmt::Result;
use std::io::Result as IOResult;
// 等价于导入std::cmp::Ordering和std::io这两个包
use std::{cmp::Ordering, fs};
// 等价于导入std::io和std::io::Write这两个包
use std::io::{self, Write};
// 导入std::collections下的所有包，一般不推荐，容易造成命名冲突
use std::collections::*;
pub fn test(){
    Result::Ok(());
    IOResult::Ok("FD");
}

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}

        pub fn seat_at_table() {}
    }

// 以下是位于lib.rs
mod front_of_house;

// 以下位于front_of_house.rs中
pub mod hosting {
    pub fn add_to_waitlist() {}

    pub fn seat_at_table() {}
}

// libs.rs
mod front_of_house;

// front_of_house.rs
mod hosting;

// front_of_house/hosting.rs
pub fn add_to_waitlist() {}
pub fn seat_at_table() {}

    // 创建一个动态数组
    let v: Vec<i32> = Vec::new();
    // 使用vec!宏来快速创建一个带有初始值的数组
    let v = vec![1, 2, 3];
    // 必须是mut的动态数组才能push进数据
    let mut v: Vec<i32> = Vec::new();
    // 往动态数组里添加数据
    v.push(5);
    v.push(6);

    // 获取数组元素的引用，如果数组越界将发生panic
    let e1: &i32 = &v[0];
    // 返回Option<&T>类型，如果不越界将返回Option
    let e2: Option<&i32> = v.get(0);

    // 注意数组元素的引用会对整个数组造成影响，这就导致了在只读引用存在的情况下无法往数组中push元素
    // 以下行无法通过编译：cannot borrow `v` as mutable because it is also borrowed as immutable
    // v.push(7);
    println!("{}", e1);

    // 使用for来遍历所有元素，这里的i为&i32
    for i in &v {
        // 5 6
        println!("{}", i)
    }
    // 这里的i值为&mut i32
    for i in &mut v {
        // 将i解引用，指向对应的值，并修改
        *i *= 2;
    }
    for i in &v {
        // 10 12
        println!("{}", i)
    }

    // 字符串字面量是&str类型
    let c: &str = "ab";
    println!("{}", c);
    // 创建一个新空字符串
    let s: String = String::new();
    // 从字面量创建一个字符串的两种方法，String::from的静态方法，&str的to_string方法
    let s = String::from("hello");
    let s = "hello".to_string();
    // 修改字符串
    let mut s = String::from("abc");
    // 往后添加字符串，push_str的参数是引用的形式&str
    s.push_str("def");
    // 插入单个字符，单个字符使用单引号
    s.push('g');
    // 使用+号拼接字符串，加号的左边是String类型，右边是&str类型，左边的变量的所有权将被加号获取而不再有效
    let s1 = String::from("hello");
    let s2 = String::from(", world");
    // s1 的所有权将被转移，不再可用，而s2由于使用引用，所以可以继续使用
    // 加号的第二个签名是&str，而我们传入的是&String也是合法的，因为Rust使用使用解引用强制转换的技术，将&s2转化为&s2[..]
    // &s2[..] 是&str类型
    let s = s1 + &s2;
    println!("{},{}", s, s2);
    let k:&str = &s[2..];
    // 使用format!宏来拼接字符串，format!不会夺取任何参数的所有权
    let s = format!("{}, {}! {}.", "hello", "world", "lee");
    println!("{}", s);
    // String采用utf-8编码，所以一个中文占用3个字节；以下输出3
    println!("{}", "我".to_string().len());
    // 虽然字符串不允许使用下标直接访问，但可以使用切片获取某个范围的字符串
    println!("{}",  &s[0..1]);
    let s = "我是中国人".to_string();
    // 需要注意如果切片的范围不是一个合法的字符串，则会直接panic
    // 以下将发生运行时panic：thread 'main' panicked at 'byte index 1 is not a char boundary; it is inside '我' (bytes 0..3) of `我`', src/main.rs:69:21
    // println!("{}", &s[0..1]);

    // 使用chars函数，可以获取根据编码获取字符串中的字符值
    for i in s.chars(){
        println!("{}", i);
    }
    // 与此相对，使用bytes，则获取每一个字节的内容
    for i in s.bytes(){
        println!("{}", i);
    }

    use std::collections::HashMap;
    // 初始化一个hashmap，不指定类型，编译器可以从h.insert里推断出类型来为HashMap<&str,i32>
    let mut h = HashMap::new();
    h.insert("lee", 1220);
    // 使用Vec来构建HashMap
    let teams = vec![String::from("blue"), String::from("yellow")];
    let scores = vec![10, 50];
    // h的类型声明是必须的，因为collect可以返回多种类型，需要明确这里需要返回的类型，但是泛型可以使用_代替，由编译器来推断
    // h的类型为HashMap<&String, &i32>
    let mut h: HashMap<_, _> = teams.iter().zip(scores.iter()).collect();
    // 获取HashMap中的值，注意这里的值是&String，不能直接使用&str
    let blue = String::from("blue");
    // get函数获取的值为Option，如果不存在，则返回None
    // get取得的结果是value的引用值，在这个场景中为&&i32
    let blue_team_score = match h.get(&blue) {
        // 由于值是&&i32，所以需要两次解引用成i32值，否则与None的返回值不匹配
        Some(i) => **i,
        None => 0,
    };
    println!("{}", blue_team_score);
    // 使用for循环获取HashMap里的值，由于使用&h，所以这里的key为&&String，value为&&i32
    for (key, value) in &h {
        println!("key:{}, value:{}", key, value);
    }


    let k = String::from("blue");
    // 更新值，如果是直接覆盖，使用insert即可
    h.insert(&k, &20);
    // 通过entry函数返回Entry枚举类型，其or_insert方法可以判断值是否存在，不存在则插入，存在则不处理
    // 其返回HashMap中value的可变引用，在此为&mut &i32，可以对其进行修改
    let e = h.entry(&k).or_insert(&30);
    *e = &11;
    // {"blue": 11, "yellow": 50}
    println!("{:?}", h);

    // 例子，查看一个字符串中每一个字符出现的次数
    let text = "hello world hello lee ok";
    let mut map = HashMap::new();
    for i in text.split_whitespace() {
        let count = map.entry(i).or_insert(0);
        *count += 1;
    }
    // {"ok": 1, "world": 1, "lee": 1, "hello": 2}
    println!("{:?}", map);

enum Result<T, E>{
    Ok(T),
    Err(E),
}

    let file_name = "Cargo.toml";
    // 对于有可能出错的函数可以返回Result，Ok表示正常返回，Err表示异常
    let mut f = match File::open(file_name) {
        Ok(file) => file,
        Err(e) => panic!("open file error:{:?}", e),
    };
    // 读取文件的内容，并输出
    let mut c = String::new();
    f.read_to_string(&mut c);
    println!("{}", c);

    let file_name = "hello.txt";
    let f = match File::open(file_name) {
        Ok(file) => file,
        // 使用e.kind()为区别不一样的类型
        Err(e) => match e.kind() {
            // 不存在的时候就创建，返回成功创建的句柄
            ErrorKind::NotFound => match File::create(file_name) {
                Ok(file) => file,
                Err(e) => panic!("create file error:{:?}", e),
            },
            // 其它错误统一命中这个分支，报错panic
            other_error => panic!("open file error:{:?}", other_error),
        }
    };

    // 使用Result.unwrap()函数来快速获取Ok的值，如果是Err，则直接panic
    let f: File = File::open(file_name).unwrap();
    // 与unwrap一样，只是传入了一个字符串做为panic时的信息
    let f: File = File::open(file_name).expect("Fail to open file");

    // 传播错误
    // 以下函数的功能等同于std::fs::read_to_string(file_name)
    fn get_content_by_file_name(name: &str) -> Result<String, io::Error> {
        let mut f = match File::open(name) {
            Ok(file) => file,
            Err(e) => return Err(e),
        };
        // 读取文件的内容，并输出
        let mut c = String::new();
        return match f.read_to_string(&mut c) {
            Ok(_) => Ok(c),
            Err(e) => Err(e),
        };
    }
    // 使用?运算符简化写法
    // 注意使用?运算符与match不一样的地方是在Err类型不匹配的时候，会自动调用from函数进行隐式转换(需要实现From trait)
    fn get_content_by_file_name2(name: &str) -> Result<String, io::Error> {
        // 如果需要将Result的Err返回，则在最后使用?表达式来达到目的
        let mut f = File::open(name)?;
        // 读取文件的内容，并输出
        let mut c = String::new();
        f.read_to_string(&mut c)?;
        Ok(c)
    }
    // 使用链式调用更加简化写法
    fn get_content_by_file_name3(name: &str) -> Result<String, io::Error> {
        let mut c = String::new();
        File::open(name)?.read_to_string(&mut c)?;
        Ok(c)
    }

fn main() {
    // 在方法中使用泛型，在函数名称后添加尖括号，并在括号中添加类型说明，
    // <T:PartialOrd + Copy>表示这个类型必须实现PartialOrd和Copy这两个Trait
    // 参数为对应类型的数组切片，返回对应类型的值
    // 由于对元素使用了大于比较计算符，所以类型T必须实现std::cmp::PartialOrd
    // 由于需要从list[0]中取出数据，所以需要实现Copy；也可以使用引用来处理
    fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
        let mut max = list[0];
        for &item in list.iter() {
            if item > max {
                max = item
            }
        }
        max
    }
    // 使用引用的版本，不需要实现Copy
    fn largest2<T: PartialOrd>(list: &[T]) -> &T {
        let mut max = &list[0];
        for item in list.iter() {
            if *item > *max {
                max = item
            }
        }
        max
    }
    println!(
        "{},{},{}, {}",
        largest(&[1, 2, 3, 4, 5, 6, 9, 3, 4, 6]),
        largest(&[1.0, 3.0, 1.1, 5.5, -1.0, -2.4]),
        // 动态数组可以转化为数组切片
        largest(&vec![1, 2, 3, 4, 5, 4, 3, 2, 1]),
        largest(&vec!['a', 'b', 'e', 'd', 'k', 'i', 'g']),
    );

    // 在结构体中使用泛型，在结构体名之后使用尖括号来声明
    struct Point<T> {
        x: T,
        y: T,
    }
    impl<T> Point<T> {
        fn x(&self) -> &T {
            &self.x
        }
        // 在泛型的结构里定义泛型的方法
        fn other<U>(&self, other: Point<U>) -> Point<U> {
            other
        }
    }

    // 在枚举中使用泛型，我们之前看到的Option和Result都有使用，不再举例
    enum Option<T> {
        Some(T),
        None,
    }
    enum Result<T, E> {
        Ok(T),
        Err(E),
    }
}

    // 定义多种文章共有的摘要功能trait
    pub trait Summary {
        fn summarize(&self) -> String;
        // trait也可以提供一个默认实现，这样实现了这一trait的结构体，如果没有提供实现，则以默认实现为准
        fn summarize2(&self) -> String {
            String::from("Read more")
        }
    }

    pub struct NewsArticle {
        pub headline: String,
        pub location: String,
        pub author: String,
        pub content: String,
    }
    // 为某一个结构实现trait，使用关键字impl和for
    // 实现的trait跟普通函数一样，可以被调用
    impl Summary for NewsArticle {
        fn summarize(&self) -> String {
            format!("{},{},{}", 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)
        }
        // 重载了默认实现，这样就无法调用到默认实现了
        fn summarize2(&self) -> String {
            format!("summarize2....")
        }
    }
    let tweet = Tweet {
        username: "lee".to_string(),
        content: "content".to_string(),
        reply: false,
        retweet: false,
    };
    // trait实现的函数，可以像普通函数一样调用，summarize2调用则是默认的实现
    println!("tweet: {}, summary2:{}", tweet.summarize(), tweet.summarize2());

    // 将trait作为参数
    // 这个函数接收实现了Summary trait的结构体类型，在这里可传入Tweet和NewsArticle
    pub fn notify<T: Summary>(item: &T) {
        println!("breaking news1:{}", item.summarize())
    }
    notify(&tweet);
    // 可以使用impl形式的语法糖来简化写法，与之前的一致
    // 是否简化也区别于实际场景，例如多个函数使用同一个约束时，使用泛型表达式则更加方便
    pub fn notify2(item: &impl Summary) {
        println!("breaking news2:{}", item.summarize())
    }
    notify2(&tweet);

    // 使用多个约束时使用+号来处理，这里的item必须实现Display和Summary两个trait
    pub fn notify3<T: Display + Summary>(item: T) {}
    // 在复杂情况下使用where语句可以使得函数签名更清晰，以下两种方式是等价的
    fn some_func<T: Display + Clone, U: Clone + Debug>(t: T, u: U) -> i32 { 1 }
    fn some_func2<T, U>(t: T, u: U) -> i32 where T: Display + Clone, U: Clone + Debug { 1 }

    // 可以返回可以使用impl形式，但只能返回一中类型，要么是Tweet，要么是NewsArticle，不能在不同的分支返回两种类型
    fn return_summarizable() -> impl Summary {
        Tweet {
            username: "".to_string(),
            content: "".to_string(),
            reply: false,
            retweet: false,
        }
    }
    // 以下无法通过编译，对于泛型，需要深入研究一下机制，为什么以下函数无法通过编译
    // fn return_summarizable2<T: Summary>(item:T) -> T {
    //     Tweet {
    //         username: "".to_string(),
    //         content: "".to_string(),
    //         reply: false,
    //         retweet: false,
    //     }
    // }

    // 使用trait约束来有条件地实现方法
    struct Point<T> {
        x: T,
        y: T,
    }
    // 为所有类型的T的Point实现new方法
    impl<T> Point<T> {
        // 大写的Self与小写的self区别
        fn new(x: T, y: T) -> Self {
            Point { x, y }
        }
    }
    // 只为实现了PartialOrd和Display的Point实现cmp方法
    impl<T: PartialOrd + Display> Point<T> {
        fn cmp(&self) {
            if self.x > self.y {
                println!("x>y")
            } else {
                println!("x<=y")
            }
        }
    }
    // 也可以使用一个trait约束来实现另外一个trait，称之为覆盖实现(blanket implementation)
    // 例如以下的例子，为了实现了Display的类型实现Summary方法
    impl<T: Display> Summary for T {
        fn summarize(&self) -> String {
            format!("read more:{}", self)
        }
    }
    // 以下例子无法通过编译，因为Display不在此包中，T这一也不在此包中，受孤儿规则限制，将报错
    // 报错：Only traits defined in the current crate can be implemented for arbitrary types [E0117]
    // impl<T: Summary> Display for T {
    //     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    //         write!(f, "({}, {})", self.x, self.y)
    //     }
    // }

    // 因为上面为实现Display的类型实现了Summary，而i32实现了Display，所以i32实现了Summary
    // 输出read more:2
    println!("{}", 2.summarize());

    let mut r = &2;
    {
        let x = 5;
        // 以下无法通过编译，因为x在内部作用域内，而r在main作用域，r的生命周期大于x，无法使用x的引用。
        // `x` does not live long enough
        // r = &x
    }
    println!("{}", r);

    // 如果不加生命周期标注的话，无法确定返回值的生命周期，无法通过编译
    // 由于x,y两个参数都用于做为引用返回，所以x,y必须都要标明生命周期
    // 这里的'a会被具体化为x,y的生命周期中重叠的那一部分
    fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
        if x.len() > y.len() {
            x
        } else {
            y
        }
    }

    let s1 = String::from("s11");
    let mut s4 = "";
    {
        let s2 = String::from("s2");
        // longest返回值的生命周期是s1和s2中生命周期较短的那个，即s2的生命周期
        // s3的生命周期与s2一样，所以能通过编译
        let s3 = longest(&s1, &s2);
        println!("{}", s3);
        // 以下无法通过编译，因为s4的生命周期大于s2
        // s4 = longest(&s1, &s2);
    }
    println!("{}", s4);

    // 以下这个函数不满足生命周期省略规则，所以必须手动标注
    // fn longest(x:&str, y:&str)->&str{}
    // 以下函数应用规则1和规则2后，所有的输入输出引用参数周期都确定，所以可以省略
    // fn first_word(x:&str)->&str{}


    // 结构体中引用字段的生命周期标
    struct ImportantExcerpt<'a> {
        part: &'a str,
    }

    impl<'a> ImportantExcerpt<'a> {
        fn level(&self) -> i32 {
            2
        }
        // 应用第一条规则和第三条规则，可以得出正确的生命周期，所以以下这个可以周期可以省略
        fn announce_and_return_part(&self, announcement: &str) -> &str {
            self.part
        }
        // 应用第一条和第三条规则，得出的生命周期不正确，所以在没有生命周期房间里时编译报错
        fn display_part_and_return<'b>(&self, announcement: &'b str) -> &'b str {
            announcement
        }
    }

    // 'static是固定写法，表示生命周期是整个程序的执行周期
    // 所有字符串字面量都拥有'static生命周期
    let s: &'static str = "abc";

    use std::fmt::Display;
    // 同时使用生命周期，泛型，trait约束的例子
    // 生命周期必须在泛型类型声明之前，也可以使用where进行trait约束
    // 生命周期也是泛型的一种？？
    fn longest_with_announcement<'a, T:Display>(x: &'a str, y: &'a str, anno: T) -> &'a str {
        println!("{}", anno);
        if x.len() > y.len() {
            x
        } else {
            y
        }
    }

//! # Adder
//!
//! 测试做为包的注释，包含有一些小组件

use std::ops::Add;

/// 定义一个泛型加法
///
/// # Example
///
/// 例子，一般是测试用例
/// ```
/// assert_eq!(5, adder::adder(3,2));
/// assert_eq!(9.8, adder::adder(3.3, 6.5));
/// ```
/// # Panics
///
/// 可能Panic的场景
///
/// # Errors
/// 如果返回Result时，这里写明Error返回的场景，以及返回的Error值
///
/// # Safety
///
/// 当使用了unsafe关键字时，这里可以说明使用unsafe的原因，以及调用者的注意事项
///
pub fn adder<T: Add + Add<Output=T>>(a: T, b: T) -> T {
    return a + b;
}

#[cfg(test)]
mod tests {
    // 引入所有父模块的所有包，这样可以直接使用adder方法，否则adder需要指定完整路径才能使用
    use super::*;
    use std::fs::File;
    use std::io::Read;

    // 标记以下函数是一个测试函数，如果没有这个标记，cargo test的时候不会运行
    #[test]
    fn it_works() {
        // 相等断言
        assert_eq!(2 + 2, 4);
    }

    #[test]
    fn adder_test() {
        // 注意使用了assert_eq和assert_ne这两个断言时，两个参数必须实现了PartialEq和Debug这两个trait，一个用于判断相等，一个用于出错时输出信息

        // 以下两个写法等价，推荐使用第一个写法，因为在失败时可以打印出两个参数的值，方便分析原因
        assert_eq!(adder(2, 2), 4);
        assert!(adder(2, 2) == 4); // assert!接收一个bool类型的参数，只有为true时测试才通过
        // assert_ne!用于断言两个值不相等
        assert_ne!(adder(2.0, 3.0), 6.0);

        // 这些断言在必要参数之后的信息都会被用于format!输出额外的信息
        assert_eq!(adder(3, 4), 7, "{}+{} is not equal 7", 3, 4);
    }

    #[test]
    // should_panic属性用于表示这个函数会发生panic
    // 参数expected会比较panic的信息是否与此相匹配，注意中人包含expected的内容即可
    #[should_panic(expected = "panicked")]
    fn check_panic() {
        panic!("i panicked")
    }

    #[test]
    // 使用Result做为测试用例的返回值时，只要有Err返回，就测试失败
    // 这种情况下可以使用?表达式来简化测试用例的编写
    fn use_result() -> Result<(), std::io::Error> {
        let mut f = File::open("./cargo.toml")?;
        let mut s = String::new();
        let _ = f.read_to_string(&mut s)?;
        return Ok(());
    }

    #[test]
    #[ignore] // 默认情况下忽略此case，可以通过--ignored来专门运行这种case
    fn long_time_test() {}
}

// src/tests/integation.rs
#[test]
fn adder_test() {
    assert_eq!(adder::adder(9.0, 10.0), 19.0);
}

#[test]
fn my_note() {
    assert_eq!(adder::adder(9.0, 10.0), 19.0);
}
mod sub;

// src/tests/sub/mod.rs
#[test]
pub fn setup() {}

// main.rs
use minigrep::*;

// main函数里的代码无法进行单元测试和集成测试，所以main函数这块保持简单，把逻辑移到lib.rs下
fn main() {
    // std::env::args()返回的是Args实现了Iterator，使用collect转化为Vec<String>
    // 因为collect返回的也是泛型，编译器无法自动推断需要返回的类型，所以给args的类型标注不可省略
    let args: Vec<String> = std::env::args().collect();

    // Result结构的unwrap_or_else方法接收一个函数来做错误处理
    // 处理函数包含一个闭包参数，使用竖线包起来，获取到的值为Result的E中的值
    // 处理函数必须返回Result的T值(正确的值)，但std::process::exit(1)直接退出进程，所以可以编译通过
    // exit的返回值为->!，表示从不会返回：pub fn exit(code: i32) -> !
    let config = Config::new(&args).unwrap_or_else(|err| {
        // 使用eprintln!将错误信息输出到标准错误输出
        eprintln!("Problem parsing arguments: {}", err);
        std::process::exit(1);
    });

    // // 使用迭代器的版本
    // let config = Config::new2(std::env::args()).unwrap_or_else(|err| {
    //     eprintln!("Problem parsing arguments: {}", err);
    //     std::process::exit(1);
    // });

    // 使用if let语法，只处理关心的变体
    if let Err(e) = run(&config) {
        eprintln!("Application error: {}", e);
        std::process::exit(1);
    }
}

// lib.rs
// 返回Result中的E为Box<dyn std::error::Error>，表示为实现了Error这一trait的类型
// 具体的类型需要在具体的场景中才能确定，这里的dyn关键字也说明了是一个动态的类型
pub fn run(config: &Config) -> Result<(), Box<dyn std::error::Error>> {
    let contents = std::fs::read_to_string(&config.filename)?;
    let result = if config.case_sensitive {
        search(&config.query, &contents)
    } else {
        search_case_insensitive(&config.query, &contents)
    };

    for l in result {
        println!("{}", l);
    }
    Ok(())
}

pub struct Config {
    query: String,
    filename: String,
    case_sensitive: bool,
}

impl Config {
    // 使用命令行参数来构造Config结构，返回Result结构，在出错时返回str
    // 返回值中的str中声明了生命周期为全局的，因为字面量常量可以是全局的，此处不设置其实也没有问题，生命周期与输入一致
    pub fn new(args: &[String]) -> Result<Config, &'static str> {
        if args.len() < 3 {
            return Err("not enough arguments!");
        }
        let query = args[1].clone();
        let filename = args[2].clone();
        // 读取环境变量来确定是否需要大小写敏感，读取到无error则case_sensitive=false，不区分大小写，如下
        // CASE_INSENSITIVE=1 cargo run Nobody poem.txt
        let case_sensitive = std::env::var("CASE_INSENSITIVE").is_err();
        // 变量与结构体字段重名时，可以使用此种方式快速构建
        Ok(Config { query, filename, case_sensitive })
    }
    // 使用迭代器版本
    pub fn new2(mut args: std::env::Args) -> Result<Config, &'static str> {
        args.next();
        let query = match args.next() {
            Some(q) => q,
            None => return Err("no query")
        };
        let filename = match args.next() {
            Some(f) => f,
            None => return Err("no filename")
        };
        let case_sensitive = std::env::var("CASE_INSENSITIVE").is_err();
        Ok(Config { query, filename, case_sensitive })
    }
}

// 这块需要指定生命周期，表明Vec返回的&str，与contents的生命周期绑定
// 如果contents失败了，那么返回值也将没有意义了
fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    let mut ret: Vec<&str> = Vec::new();
    for line in contents.lines() {
        if line.contains(query) {
            ret.push(line)
        }
    }
    ret
    // 使用迭代器版本
    // contents.lines().filter(|line| line.contains(query)).collect()
}

fn search_case_insensitive<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    let mut ret: Vec<&str> = Vec::new();
    let q = query.to_lowercase();
    for l in contents.lines() {
        if l.to_lowercase().contains(&q) {
            ret.push(l)
        }
    }
    ret
}

#[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.
        ";
        assert_eq!(
            vec!["Rust:"],
            search_case_insensitive(query, contents),
        );
    }
}

fn main() {
    // 闭包当作匿名函数的一般写法，参数和返回值的类型，由编译器推断出来
    let add_one = |x| {
        x + 1
    };
    // 如果无法推断，则需要写成这种详细的形式，与函数定义非常类似
    let add_one2 = |x: i32| -> i32{
        x + 1
    };
    // 在匿名函数没有捕获环境变量的情况下，与函数一样
    fn add_one_fn(x: i32) -> i32 {
        x + 1
    }

    fn use_fn(x: i32, f: fn(i32) -> i32) -> i32 {
        f(x)
    }

    // 输出2,2,2
    // 可见无捕获上下文的闭包与函数一样
    println!("{},{},{}", use_fn(1, add_one), use_fn(1, add_one2), use_fn(1, add_one_fn));

    // 如果捕获了环境变量，则闭包与函数就不能通用了
    let k = 1;
    let add_one_closure = |x: i32| {
        x + k + 1
    };
    // 这里报错，expected fn pointer, found closure
    // closures can only be coerced to `fn` types if they do not capture any variables
    // println!("{}", use_fn(1, add_one_closure));

    // 函数无法捕获上下文:can't capture dynamic environment in a fn item
    //  use the `|| { ... }` closure form instead
    // fn f_error(x: i32) -> i32 {
    //     x + k + 1;
    // }

    // 以下正常运行，输出12
    println!("{}", add_one_closure(10));

    // 多个参数时，使用逗号隔离开
    let sum = |x, y| {
        x + y
    };
    // 如果只有一行，可以省略掉大括号
    let sum2 = |x, y| x + y;
    println!("{},{}", sum(1, 2), sum2(2, 3));

    // 在不指定类型的闭包，只能推断出一种类型
    let closure = |x| x;
    println!("{}", closure(10));
    // 以下将报错，办为之前的调用已经推断closure为(i32)->i32的闭包，不能再使用&str类型了
    // expected integer, found `&str`
    // println!("{}", closure("10"));

    // 与闭包相关的三种trait： Fn, FnMut, FnOnce，所有闭包至少实现其中的一个
    // 这三个trait代表了函数接收参数的三种方式：不可变引用(Fn)，可变引用(FnMut)，获取所有权(FnOnce)
    // rust自动从闭包的定义中推导出其所实现的trait
    // 所有函数都实现了这三个trait，所以要求传闭包的地方都可以传函数

    // 这三个trait的区别：
    // 实现了FnOnce的闭包可以从环境中获取变量的所有权，所以这个类型的闭包只能被调用一次
    // 实现了FnMut的闭包从环境中可变地借用值
    // 实现了Fn的闭包从环境中不可变地借用值
    // 所有闭包都实现了FnOnce，实现了Fn的闭包也实现了FnMut
    // 接收Fn trait做为参数的函数
    fn do_1<T: Fn(i32) -> i32>(x: i32, f: T) -> i32 {
        f(x)
    }
    let k = vec![1, 2];
    let c_1 = |x| x + k[0] + 1;
    fn f_1(x: i32) -> i32 { x + 1 }
    //
    // 输出5,3
    println!("{},{}", do_1(1, c_1), do_1(1, f_1));
    println!("{}", c_1(1));

    // 使用move关键可以获取变量的所有权
    let c_1 = move |x| x + k[0] + 1;
    // ？？？很奇怪的现象，如果加上下面这一行，则后面的两次调用将报错: borrow of moved value: `c_1`
    // 但如果没有下面这一行，则后面的两次调用则可以通过
    // do_1(1, c_1);
    println!("{}", c_1(1));
    println!("{}", c_1(1));


    // FnOnce的例子
    fn do_2<T: Fn() -> String>(f: T) {
        f();
    }
    let a = "aa".to_string();
    // c_2因为返回了a变量，而String没有实现Copy trait，所以相当于c_2获取了a的所有权并返回了a，所以c_2只实现了FnOnce trait，无法被传递到Fn作为参数的函数中
    let c_2 = || a;
    // 以下一行将报错： this closure implements `FnOnce`, not `Fn`
    // do_2(c_2);
    fn do_3<T: FnOnce() -> String>(f: T) {
        f();
    }
    // 运行正常
    do_3(c_2);
    // 以下编译报错： use of moved value: `c_2`
    // 因为c_2是FnOnce没有实现Copy，所以无法被使用两次
    // do_3(c_2);

    // FnMut的例子
    let mut k = 3;
    let mut c_3 = || {
        k = k + 1;
        k
    };
    println!("{}", c_3());
    // 以下将无法通过编译，因为c_3使用k的可变引用，不能再拥有k的其它引用了
    // println!("{},{}", k, c_3());
}

fn main() {
    // 迭代器允许你依次为序列中的每一个元素执行某些任务
    // 迭代器是惰性的，除非主动调用方法来消耗，否则不会有任何作用
    // 迭代器实现了Iterator 这一trait，Iterator有多个方法，但大多都提供了默认的实现
    // 要实现Iterator只需要实现next方法即可
    trait Iterator1 {
        // 关联类型，用于存储next返回值的类型
        type Item;
        // Self::Item表示返回的Option存储的是Item的类型
        // next返回被包裹在Some中的元素，在遍历结束时返回None
        fn next(&mut self) -> Option<Self::Item>;
        // 省略默认实现的方法
        // ...
    }

    let mut v = vec![1, 2, 3];
    // 必须将iter标识成mut的，因为调用next会改变iter内部的状态
    // iter()方法返回的是一个不可变引用迭代器，next的返回值是数组中元素的不可变引用
    let mut iter = v.iter();
    // 1,2,3,true
    println!("{},{},{},{}", iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next() == None);
    // 返回可变引用
    for i in v.iter_mut() {
        *i += 1;
    }
    // [2,3,4]
    println!("{:?}", v);

    // 使用into_iter获取其所有权，后续v不再可用
    println!("{}", v.into_iter().next().unwrap());

    // 迭代适配器，以及与闭包共同实现
    let v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];
    let add2: Vec<i32> = v.iter().map(|x| x + 2).collect();
    let min = 5;
    // 这里使用filter的给到的闭包参数为&&x，要么使用**x解引用，要么在参数中使用&&x来表示x是一个i32
    let big: Vec<&i32> = v.iter().filter(|&&x| x + 2 > min).collect();
    // [3, 4, 5, 6, 7, 8, 9, 10, 11],[6, 7, 8, 9]
    println!("{:?},{:?}", add2, big);

    // 创建自定义的迭代器
    struct Counter {
        count: i32,
    }
    impl Counter {
        fn new() -> Counter {
            Counter { count: 0 }
        }
    }
    impl std::iter::Iterator for Counter {
        type Item = i32;

        fn next(&mut self) -> Option<Self::Item> {
            self.count += 1;
            if self.count > 5 {
                None
            } else {
                Some(self.count)
            }
        }
    }
    for i in Counter::new() {
        println!("{}", i)
    }
    // 一些迭代器复杂的用法
    // Iterator这个trait有很多方法的默认实现，依赖于next方法，我们可以直接使用完成复杂的功能
    // 以下有一个特殊的语法，在方法后面添加::<typeHint>，可以给编译器提示返回的值类型为typeHint，用于无法推断类型的场景时使用
    // Counter::new() is [1, 2, 3, 4, 5]
    // Counter::new().skip(1) is [2, 3, 4, 5]
    // Counter::new().zip(Counter::new().skip(1)) is [(1, 2), (2, 3), (3, 4), (4, 5)]
    //     .map(|(a,b)| a*b) is [2, 6, 12, 20]
    //     .filter(|x| x % 3 == 0) [6, 12]
    //     .sum() is 18
    let c: i32 = Counter::new().zip(Counter::new().skip(1))
        .map(|(a, b)| a * b)
        .filter(|x| x % 3 == 0)
        .sum();
    println!("Counter::new() is {:?}", Counter::new().collect::<Vec<i32>>());
    println!("Counter::new().skip(1) is {:?}", Counter::new().skip(1).collect::<Vec<i32>>());
    println!("Counter::new().zip(Counter::new().skip(1)) is {:?}", Counter::new().zip(Counter::new().skip(1)).collect::<Vec<(i32, i32)>>());
    println!("    .map(|(a,b)| a*b) is {:?}", Counter::new().zip(Counter::new().skip(1)).map(|(a, b)| a * b).collect::<Vec<i32>>());
    println!("    .filter(|x| x % 3 == 0) {:?}", Counter::new().zip(Counter::new().skip(1)).map(|(a, b)| a * b).filter(|x| x % 3 == 0).collect::<Vec<i32>>());
    println!("    .sum() is {:?}", c);
}

// 位于adder项目中
/// 定义一个泛型加法
///
/// # Example
///
/// 例子，一般是测试用例
/// ```
/// assert_eq!(5, adder::adder(3,2));
/// assert_eq!(9.8, adder::adder(3.3, 6.5));
/// ```
/// # Panics
///
/// 可能Panic的场景
///
/// # Errors
/// 如果返回Result时，这里写明Error返回的场景，以及返回的Error值
///
/// # Safety
///
/// 当使用了unsafe关键字时，这里可以说明使用unsafe的原因，以及调用者的注意事项
///
pub fn adder<T: Add + Add<Output=T>>(a: T, b: T) -> T {
    return a + b;
}

// example/src/lib.rs
//! # Art
//!
//! 测试用于艺术建模的库

// 使用pub use 重新组织API结构
pub use crate::kinds::PrimaryColor;
pub use crate::kinds::SecondaryColor;
pub use crate::utils::mixed;

pub mod kinds {
    pub enum PrimaryColor {
        Red,
        Yellow,
        Blue,
    }

    pub enum SecondaryColor {
        Orange,
        Green,
        Purple,
    }
}

pub mod utils{
    use crate::kinds::*;

    pub fn mixed(c1:PrimaryColor, c2:PrimaryColor) -> SecondaryColor{
        SecondaryColor::Orange
    }
}

// example/src/bin/pub_use_example.rs

// use example::kinds::PrimaryColor;
// use example::utils::mixed;

// 使用pub use重新导出包结构后，就可以使用直接使用一级目录的结构，不用关心原包中的结构了
use example::PrimaryColor;
use example::mixed;

fn main(){
    let red = PrimaryColor::Red;
    let yellow = PrimaryColor::Yellow;
    mixed(red, yellow);

}

    // Box的基本使用方法
    // a和b都是Box<i32>类型，与i32不同的是，Box<i32>类似于指向堆上两个i32类型的指针
    let a = Box::new(128);
    let b = Box::new(256);
    // 所以a和b无法直接进行操作，因为Box实现了Deref这一trait，所以可以使用*来解引用
    let c: i64 = *a + *b;
    println!("{}", c); // 384

    // 递归类型必须使用Box
    enum List {
        Cons(i32, Box<List>),
        // 使用Cons(i32, List)将无法通过编译：recursive type `List` has infinite size
        Nil,
    }

    use List::{Nil, Cons};

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

    fn print_list(l: List) {
        match l {
            Cons(i, nl) => {
                print!("{}=>", i);
                print_list(*nl);
            }
            Nil => {
                println!("end");
            }
        }
    }
    print_list(list);

   // 自定义类似于Box的智能指针(但数据存在在栈上)
    struct MyBox<T> (T); // 元组结构体
    impl<T> MyBox<T> {
        // 提供一个参数，并将此存入结构体中
        fn new(x: T) -> MyBox<T> {
            MyBox(x)
        }
    }

    // 为MyBox实现Deref，这样就可以使用解引用运算符
    impl<T> Deref for MyBox<T> {
        // 关联类型
        type Target = T;

        // 也可以写成fn deref(&self) -> &T {
        fn deref(&self) -> &Self::Target {
            // 以下等价于self.0
            match self {
                MyBox(i) => i
            }
        }
    }
    let a = MyBox(10);
    // 这里的*a类似于*(a.deref())，称之为隐式展开
    println!("{}", *a + 10)

    // 隐式解引用转换
    fn hello(name: &str) {
        println!("hello, {}", name);
    }
    let mb: MyBox<String> = MyBox::new("lee".to_string());
    // 正常的写法如下，其发生的步骤1. 需要将MyBox解引用转化为String，2. 使用[..]将String转化为切片&str，这样才符合参数要求
    hello(&(*mb)[..]);
    // 使用自动解引用也能满足这个要求，mb实现了Deref，所以可以获取到String，String也实现了deref，其返回为&str，所以编译器进行了两次解引用转换
    // 以上是编译期完成，不会有任何运行时开销
    hello(&mb);

    // 实现可变解引用运算符，实现DerefMut之前必须实现Deref
    impl<T> DerefMut for MyBox<T> {
        fn deref_mut(&mut self) -> &mut Self::Target {
            &mut self.0
        }
    }
    // 满足自动解引用的三条规则
    // 当T: Deref<Target=U>时，允许&T转换为&U。
    // 当T: DerefMut<Target=U>时，允许&mut T转换为&mut U。
    // 当T: Deref<Target=U>时，允许&mut T转换为&U。
    fn hello_exp(name: &mut String) -> &mut String {
        name.push_str(", hello!");
        name
    }

    let mut b = Box::new("abc".to_string());
    // 当T: DerefMut<Target=U>时，允许&mut T转换为&mut U，与&mut *b是一样的
    let c = hello_exp(&mut b);
    println!("{}", c);
    //  当T: Deref<Target=U>时，允许&mut T转换为&U。
    hello(&mut b);

    // 实现Drop的例子
    {
        struct TestDropStruct {
            data:String,
        }
        impl Drop for TestDropStruct{
            fn drop(&mut self) {
                println!("{}", self.data)
            }
        }
        let _a = TestDropStruct{data:"first object".to_string()};
        let _b = TestDropStruct{data:"second object".to_string()};
        let _c = TestDropStruct{data:"third object".to_string()};
        println!("main end");
        // 手动使用std::mem::drop函数来提前清理_c的值
        drop(_a);

        // 以上输出顺序为
        // main end
        // first object
        // third object
        // second object
        // 对于_b，_c来说，丢弃顺序与创建顺序相反，所以_c先调用drop函数
        // _a则是由于手动释放导致先执行
    }

     {
        // 测试引用计数智能指针Rc<T>类型
        enum RcList {
            RcCons(i32, Rc<RcList>),
            RcNil,
        }
        use RcList::*;
        // 新建一个引用记录类型使用Rc::new来创建，此处a为Rc<RcList>类型
        let a = Rc::new( RcCons(3, Rc::new(
            RcCons(4, Rc::new(RcNil)),
        )));
        {
            // Rc::clone全程参数对应的引用计数增加1
            let _b = RcCons(1, Rc::clone(&a));
            let _c = RcCons(2, Rc::clone(&a));
            // 目前有a,_b,_c三个变量引用a，所以a的引用计数为3
            // 除了strong_count，还有week_count，用于避免循环引用
            println!("{}", Rc::strong_count(&a))
        }
        // _b，_c离开作用域，减少了引用计数，但a还在，所以这块的数量是1
        println!("{}", Rc::strong_count(&a))
    }