mod front_of_house{ // 注意，如果是根级，可以不加pub
    pub mod hosting { // mod可以嵌套 注意这个需要使用公有
        pub fn add_to_waitlist(){} // 注意也需要使用公有
    }
}
pub fn eat_at() {
    crate::front_of_house::hosting::add_to_waitlist(); // 绝对路径

    front_of_house::hosting::add_to_waitlist(); // 相对路径
}

fn serve_order() {}

mod back_of_house {
    fn fix_incorrect_order() {
        super::serve_order(); // 这里面直接跳出了back_of_house这个mod，而不是fix_incorrect_order函数作用域
        crate::serve_order(); // 绝对路径
    }
}

// use std::cmp::Ordering
// use std::io
use std::{
    cmp::Ordering,
    io
};


// use std::io
// use std::Write
use std::io::{
    self,
    Write
};

use std::io::*;




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

pub use crate::front_of_house:hosting; // 这里就是将hosting这个模块引入到当前根，在同一个根内可以直接通过hosting::add_to_waitlist();调用，这个也是绝对路径， pub这个是可以重新导出

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

// src\lib.rs
mod front_of_house; // rust会在本mod下面寻找这个mod的名字，如src\front_of_house.rs

//假设如果还有一个子模块还有文件导入（如mod hosting）的话，可以创建一个名为front_of_house的包，然后再包中创建hosting.rs文件

// src\front_of_house\hosting.rs

cargo new (project's name)  //创建一个新的 cargo 项目
cargo build                 //编译项目
cargo run                   //对项目进行编译，然后再运行

[source.crates-io]
replace-with = 'rsproxy-sparse'
[source.rsproxy]
registry = "https://rsproxy.cn/crates.io-index"
[source.rsproxy-sparse]
registry = "sparse+https://rsproxy.cn/index/"
[registries.rsproxy]
index = "https://rsproxy.cn/crates.io-index"
[net]
git-fetch-with-cli = true

let mut y=10；//可变变量
y = 20;//合法的修改

let a = 10;
let a = 20; // Shadowing Variables

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
    Square(f64),
    Unknown, // 表示不知道是否有这个类型，什么类型也不知道
}

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

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

match number {
    0=> println!("Zero"),
    1|2 => println!("One or Two"),
    3..=9 => println!("From Three to Nine"),
    n if n % 2 == 0 => println!("Even number"),
    _ => println!("Other"),
}

enum Color {
    Red,
    Yellow,
    Blue,
    Block,
}

fn print_color(my_color: Color) {
    match my_color {
        Color::Red => println!("Red"),
        Color::Yellow => println!("Yellow"),
        Color::Blue => println!("Blue"),
        _ => println!("Other"),
    }
}

fn main() {
    print_color(Color::Yellow);
}

enum BuildingLocation {
    Number(i32),
    Name(String), // 不用&str等来进行匹配
    Unknown,
}

impl BuildingLocation {
    fn print_location(&self) {
        match self {
            BuildingLocation::Number(c) => println!("building number{}", c),
            BuildingLocation::Name(s) => println!("building name{}", s),
            BuildingLocation::Unknown => println!("unknown"),
        }
    }
}

// 调用
let house: BuildingLocation = BuildingLocation::Name("fdgd".to_string());
house.print_location();

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

fn main() {
    let msgs = [
        Message::Quit,
        Message::Move { x: 1, y: 3 },
        Message::ChangeColor(255, 255, 0)
    ];

    for msg in msgs {
        show_message(msg);
    }
}

fn show_message(msg: Message) {
    match msg {
        Message::Move { x, y } => {
            assert_eq!(x, 1);
            assert_eq!(y, 3);
        },
        // 或者下面的写法
        Message::Move { x: a, y: b } => {
            assert_eq!(a, 1);
            assert_eq!(b, 3);
        },
        Message::ChangeColor(_, g, b) => {
            assert_eq!(g, 255);
            assert_eq!(b, 0);
        },
        _ => println!("no data in these variants")
    }
}

rustuse std::vec::Vec;

fn main() {
    // 创建并初始化向量
    let mut vec = Vec::new(); // 创建一个空向量
    // let mut vec = vec![1,2,3];
    vec.push(1); // 添加元素

    // 访问元素
    println!("{:?}", vec[0]); // 输出第一个元素
    match vec.get(1) {
        Some(third) => println!("{:?}", third),
        None => println!("没有元素"),
    } // 输出第二个元素 // 返回的是一个Option枚举
    
    // 遍历向量
    for elem in &vec {
        println!("{}", elem);
    }

    // 删除最后一个元素
    vec.pop();

    // 获取长度
    println!("Length: {}", vec.len());
}

rustuse std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert("one", 1);
    map.insert("two", 2);

    // 访问值
    match map.get(&"one") {
        Some(value) => println!("The value for 'one' is: {}", value),
        None => println!("No entry found for 'one'"),
    }

    // 遍历哈希映射
    for (key, value) in &map {
        println!("{}: {}", key, value);
    }
}

rustuse std::collections::HashSet;

fn main() {
    let mut set: HashSet<i32> = HashSet::new();
    set.insert(1);
    set.insert(2);
    set.insert(3);

    // 检查成员
    if set.contains(&2) {
        println!("Set contains the number 2");
    }

    // 遍历集合
    for &num in &set {
        println!("{}", num);
    }
}

rustuse std::collections::LinkedList;

fn main() {
    let mut list: LinkedList<i32> = LinkedList::new();
    list.push_back(1);
    list.push_back(2);
    list.push_front(0);

    // 遍历链接列表
    for elem in &list {
        println!("{}", elem);
    }
}

let s1 = String::from("hello");
let s2 = s1; // s1的所有权转移到s2，s1不能再使用

fn take_ownership(s: String) {
   println!("{}", s);
}
   
let s = String::from("hello");
take_ownership(s); // s的所有权转移到take_ownership函数内

fn returns_string() -> String {
   String::from("hello")
}

let s = returns_string(); // 返回值的所有权转移到s

let a = 5;
let b = a; // 这里 a 的值被复制给了 b 没有涉及到搜有权转移

let x = "ss".to_string();
let y = x;
print!("{:?}", x); //会报错，所有权转移了

// 解决方案 clone()
let y = x.clone();

let x = 10;
println!("x : {}", x);
println!("x : {x}");

println!("u32 max: {}", u32::MAX);
println!("u32 min: {}", i32::MIN);
println!("isize is {} bytes", std::mem::size_of::<isize>()); // 查看数据的字节数


let f1: f32 = 1.23234
println!("Float are {:.2}", f1); // 1.23 打印两位

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

fn string_func_borrow(s: &String) {
    println!("{}", (*s).to_uppercase()) // *获取值
}


let s = String::from("hello");
string_func_borrow(&s); // 使用&传递

struct Point {
    x: i32,
    y: i32,
}

fn modify_point(point: &mut Point) {
    (*point).x += 2; // 原始
    point.y += 2; // 编译器会自动处理解引用的过程
}


let mut p = Point { x: 1, y: 2 };
modify_point(&mut p);

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

fn divide(a: i32, b: i32) -> Result<f64, String> {
    if b == 0 {
        return Err(String::from("cannot be zero"));
    }

    let a: f64 = a as f64;
    let b: f64 = b as f64;
    Ok(a / b)
}

fn main() {
    // result
    match divide(a: 1, b: 2) {
        Ok(number) => println!("{}", number),
        Err(err) => println!("{}", err),
    }
}

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

fn find_element(array: &[i32], target: i32) -> Option<usize> {
    for (index, &item) in array.iter().enumerate() {
        if item == target {
            return Some(index);
        }
    }
    None
}

fn main() {
    let arr = [1, 2, 3, 4, 5];

    match find_element(&arr, 4) { 
        Some(index) => println!("Found at index {}", index),
        None => println!("None"),
    }
}

// 第一种系统自带的
let arr = vec![1, 2, 3, 4, 5];
arr[34]; // 数组越界就是

fn main() {
    let result_ok: Result<i32, &str> = Ok(32);
    let value: i32 = result_ok.unwrap();
    println!("{}", value);


    let result_err: Result<i32, &str> = Err("ff");
    let value: i32 = result_err.unwrap();
}

fn test() {
    let result_ok: Result<i32, &str> = Ok(32);
    let value: i32 = result_ok?;
    println!("{}", value);
}

fn parse_numbers(input: &str) -> Result<i32, ParseIntError> {
    let val= input.parse::<i32>()?;
    Ok(val);
}

match parse_numbers("d"){
    Ok(i） => println!("parsed {}",i),
        Err(err) => println!("failed to parse: {}", err),
    }

// 第一步，创建结构体，表示错误类型，描述错误详情
#[derive(Debug)]
struct MyError {
    detail: String,
}

// 第二步，实现std::fmt::Display特质，实现打印方法
impl std::fmt::Display for MyError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "MyError: {}", self.detail)
    }
}

// 第三步，实现std::error::Error特质，实现基础机制（包括不限于，错误传递）
impl std::error::Error for MyError {
    fn description(&self) -> &str {
        // 这里&String自动转换成&str
        &self.detail
    }
}

fn do_something() -> Result<(), MyError> {
    // 这里实现一些操作，可能会返回错误
    // 如果返回错误，使用MyError来封装错误信息
    Err(MyError {
        detail: String::from("Something went wrong"),
    })
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 使用match匹配模式
    match do_something() {
        Ok(_) => println!("Everything went well"),
        Err(err) => println!("Error: {}", err),
    }

    // 或者使用?操作符简化代码
    do_something()?;
    Ok(())
}

// src/lib.rs 或 src/main.rs

#[cfg(test)]
mod tests {
    
    use super::*;
    
    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
        assert_eq!(add(-1, 1), 0);
        assert_eq!(add(0, 0), 0);
    }
}

fn get_length(s: String) -> usize {
    println!("{}", s);
    s.len()
}

fn main() {
    let s1 = String::from("vlaue");
    let s1_len = get_length(s1);

    println!("{}", s1_len);
}

fu dangle() -> &str{}

// 没有返回值，不用标注生命周期
fn print(s: &str) {
    println!("s: {}", s)
}

// 不是引用时，不用标注生命周期
fn clone(s: &str) -> String {
    s.to_owned()
}

// 在返回引用时，只有一个参数和返回值，Rust内部自动帮忙标注隐式生命周期
fn get(s: &str) -> &str {
    s
}

// 不确定返回的引用，使用where来限定，进行对多个生命周期取交集，这种更灵活性能好
fn long<'a, 'b, 'out>(s1: &'a str, s2: &'b str) -> &'out str
where
    'a: 'out,
    'b: 'out,
{
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

// 临时处理，使用静态生命周期'static，这种耗费性能，一般在处理生命周期比较烦的时候又编译不过时临时使用一下
fn urgent(s1: &'static str, s2: &'static str) -> &'static str {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}


fn main() {
    // 函数
    print("hello rust");

    let s = clone("hello rust");
    println!("s: {}", s);

    let s = get("hello rust");
    println!("s: {}", s);

    let s = long("hello world", "hello rust");
    println!("s: {}", s);

    let s = urgent("hello world", "hello rust");
    println!("s: {}", s);
}

// 对比组，与下面Person结构体
struct Point {
    x: i32,
    y: i32,
}

// 在结构体中，使用了引用，需要标注生命周期
#[derive(Debug)]
struct Person<'a> {
    name: &'a str,
}

// 关键函数，生命周期标注示例
impl<'a> Person<'a> {
    fn get_name(&self) -> &str {
        // 自动解引用强制特性，self.name = (*self).name
        self.name
    }
}

fn main() {

    // 结构体
    let name = "danile"; // 引用具有copy特质
    let p = Person { name: name };
    println!("p: {:?}, name: {}", p, p.get_name())
}

impl Point {
    fn distance(&self, other: &Point) -> f64 {
        let dx = (self.x - other.x) as f64;
        let dy = (self.y - other.y) as f64;
        (dx * dx + dy * dy).sqrt()
    }
}

impl Point {
    fn name(x: u32, y: u32) -> Self {
        Point { x, y }
    }
}

// 调用
Point::name(x, y);

impl Point {
    const PI: f64 = 3.14;
}

// 调用
Point::PI

impl Point {
    get(self: Self) -> i32 {
        self.x
    }
}

struct Point {
    x: i32,
    y: i32,
}

// 使用new将数据存储在堆上
let boxed_point = Box::new(Point { x: 1, y: 2 });

let mut boxed_point = Box::new(32);
*boxed_point += 10;

// 使用一个泛型类型
#[derive(Debug)]
struct Point<T> {
    x: T,
    y: T,
}

// 使用多个泛型类型
#[derive(Debug)]
struct Car<T, E> {
    name: T,
    price: E,
}

fn main() {
    // 结构体
    // 隐式写法
    let point = Point { x: 5, y: 10 };
    println!("point: {:?}", point);
    // 显示写法
    let point = Point::<f64> { x: 1.2, y: 1.3 };
    println!("point: {:?}", point);
    
    // 结构体的方法
    let p = point.get();
    print!("point: {:?}", p);

    let car = Car {
        name: String::from("BYD"),
        price: 240_000,
    };
    println!("car: {:?}", car);
}

// 交换
fn swap<T>(a: T, b: T) -> (T, T) {
    (b, a)
}

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn new(x: T, y: T) -> Self {
        Point { x, y }
    }
    // 方法
    fn get_coordinates(&self) -> (&T, &T) {
        (&self.x, &self.y)
    }
}

fn main() {
    let result = swap::<f64>(0.1, 1.0);
    let result: (f64, f64) = swap(0.1, 1.0);
    println!("{:?}", result);
    let str2 = swap("hh", "tt");
    println!("str2.0 {} str2.1 {}", str2.0, str2.1);
    let str2 = swap(str2.0, str2.1);
    println!("str2.0 {} str2.1 {}", str2.0, str2.1);

    let i32_point = Point::new(2, 3);
    let f64_point = Point::new(2.0, 3.0);
    let (x1, y1) = i32_point.get_coordinates();
    let (x2, y2) = f64_point.get_coordinates();
    println!("i32 point: x= {} y= {}", x1, y1);
    println!("f64 point: x= {} y= {}", x2, y2);
    // String 不要用&str
    let string_point = Point::new("xxx", "yyyy");
    println!("string point x = {} y = {}", string_point.x, string_point.y);
}

trait Summary {
    fn summarize(&self) -> String;
}

struct NewsArticle {
    headline: String,
    location: String,
    author: String,
    content: String,
}

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

fn notify(item: impl Summary) {
    println!("Breaking news: {}", item.summarize());
}

let article = NewsArticle { /*...*/ };
let tweet = Tweet { /*...*/ };

let items = vec![Box::new(article) as Box<dyn Summary>, Box::new(tweet)];

trait Display {
    fn display(&self) -> String {
        format!("Displaying {}", self.describe())
    }

    fn describe(&self) -> String;
}

let o = Object{};
let o_obj: &dyn Object = &o;

let o_obj: &dyn Object = &Object{};

let o_obj: Box<dyn Object> = Box::new(Object{});

// trait 不可变引用 \ Move
struct Obj {}
trait Overview {
    fn overview(&self) -> String {
        String::from("overview")
    }
}

impl Overview for Obj {
    fn overview(&self) -> String {
        String::from("Obj")
    }
}
// 不可变引用
fn call_obj(item: &impl Overview) {
    println!("Overview {}", item.overview());
}
// Move
fn call_obj_box(item: Box<dyn Overview>) {
    println!("Overview {}", item.overview());
}

// 集合的例子
trait Sale {
    fn amount(&self) -> f64;
}

struct Common(f64);
impl Sale for Common {
    fn amount(&self) -> f64 {
        self.0
    }
}

struct TenDiscount(f64);
impl Sale for TenDiscount {
    fn amount(&self) -> f64 {
        self.0 - 10.0
    }
}

struct TenPercentDiscount(f64);
impl Sale for TenPercentDiscount {
    fn amount(&self) -> f64 {
        self.0 * 0.9
    }
}

fn calculate(sales: &Vec<Box<dyn Sale>>) -> f64 {
    sales.iter().map(|sale| sale.amount()).sum()
}

fn main() {
    let a = Obj {};
    call_obj(&a);
    println!("{}", a.overview());
    let b_a = Box::new(Obj {});
    call_obj_box(b_a);
    // println!("{}", b_a.overview());
    
    // 集合的例子
    let c: Box<dyn Sale> = Box::new(Common(100.0));
    let t1: Box<dyn Sale> = Box::new(TenDiscount(100.0));
    let t2: Box<dyn Sale> = Box::new(TenPercentDiscount(200.0));

    let sales = vec![c, t1, t2]; // : Vec<Box<dyn Sale>>

    println!("pay {}", calculate(&sales));
}

trait Overview {
    fn overview(&self) -> String {
        String::from("Course")
    }
}

trait Another {
    fn hell(&self) {
        println!("welcome to hell");
    }
}

struct Course {
    headline: String,
    author: String,
}

impl Overview for Course {}
impl Another for Course {}

struct AnotherCourse {
    headline: String,
    author: String,
}

impl Overview for AnotherCourse {}

// 单个impl写法
fn call_overview(item: &impl Overview) {
    println!("Overview {}", item.overview());
}

// 单个泛型写法
fn call_overview_generic<T: Overview>(item: &T) {
    println!("Overview {}", item.overview());
}

// 单个impl写法 多参 可以传多个参数类型
fn call_overviewT(item: &impl Overview, item1: &impl Overview) {
    println!("Overview {}", item.overview());
    println!("Overview {}", item1.overview());
}

// 单个泛型写法 多参，泛型的多参只能是一个泛型
fn call_overviewTT<T: Overview>(item: &T, item1: &T) {
    println!("Overview {}", item.overview());
    println!("Overview {}", item1.overview());
}

// 多特质情况 
fn call_mul_bind(item: &(impl Overview + Another)) {
    println!("Overview {}", item.overview());
    item.hell();
}

fn call_mul_bind_generic<T>(item: &T)
where
    T: Overview + Another,
{
    println!("Overview {}", item.overview());
    item.hell();
}

fn main() {
    let c0 = Course {
        headline: "ff".to_owned(),
        author: "yy".to_owned(),
    };
    let c1 = Course {
        headline: "ff".to_owned(),
        author: "yy".to_owned(),
    };

    let c2 = AnotherCourse {
        headline: "ff".to_owned(),
        author: "yz".to_owned(),
    };
    // call_overview(&c1);
    // call_overview_generic(&c1);
    // call_overviewT(&c1, &c2);
    // println!("-------------------");
    // call_overviewTT(&c1, &c0);
    // call_overviewT(&c1, &c0);
    call_mul_bind(&c1);
    call_mul_bind_generic(&c1);
}

use std::ops::Add;

// 编译时
#[derive(Debug)]
struct Point<T> {
    x: T,
    y: T,
}

// T的这样类型 它可以执行相加的操作
impl<T> Add for Point<T>
where
    T: Add<Output = T>,
{
    type Output = Self;
    fn add(self, rhs: Self) -> Self::Output {
        Point {
            x: self.x + rhs.x,
            y: self.y + rhs.y,
        }
    }
}

fn main() {
    let i1 = Point { x: 1, y: 2 };
    let i2 = Point { x: 1, y: 3 };
    let sum = i1 + i2;
    println!("{:?}", sum);
    let f1 = Point { x: 1.0, y: 2.2 };
    let f2 = Point { x: 1.0, y: 3.0 };
    let sum = f1 + f2;
    println!("{:?}", sum);
}

use std::collections::VecDeque;
// 多态
trait Driver {
    fn drive(&self);
}
struct Car;
impl Driver for Car {
    fn drive(&self) {
        println!("Car is driving");
    }
}

struct SUV;
impl Driver for SUV {
    fn drive(&self) {
        println!("SUV is driving");
    }
}

fn road(vehicle: &dyn Driver) {
    vehicle.drive();
}


// 继承思想
// 单向特质
trait Queue {
    fn len(&self) -> usize;
    fn push_back(&mut self, n: i32);
    fn pop_front(&mut self) -> Option<i32>;
}

// 双向特质
trait Deque: Queue { // 这里就差不多继承
    fn push_front(&mut self, n: i32);
    fn pop_back(&mut self) -> Option<i32>;
}


#[derive(Debug)]
struct List {
    data: VecDeque<i32>,
}

impl List {
    fn new() -> Self {
        let data = VecDeque::<i32>::new();
        Self { data }
    }
}

impl Deque for List {
    fn push_front(&mut self, n: i32) {
        self.data.push_front(n)
    }

    fn pop_back(&mut self) -> Option<i32> {
        self.data.pop_back()
    }
}

impl Queue for List {
    fn len(&self) -> usize {
        self.data.len()
    }

    fn push_back(&mut self, n: i32) {
        self.data.push_back(n)
    }

    fn pop_front(&mut self) -> Option<i32> {
        self.data.pop_front()
    }
}

fn main() {
    // road(&Car);
    // road(&SUV);

    let mut l = List::new();
    l.push_back(1);
    l.push_front(0);
    println!("{:?}", l);
    l.push_front(2);
    println!("{:?}", l);
    l.push_back(2);
    println!("{:?}", l);
    println!("{}", l.pop_back().unwrap());
    println!("{:?}", l);
}

// 定义错误类型
#[derive(Debug)]
enum UserFileError {
    PermissionDenied,
    ValidationError,
}

// 定义一个通用的结果类型
type UserFileResult<T> = Result<T, UserFileError>;

// 定义 `Diff` 枚举，用于标记文件是否被修改
#[derive(Debug)]
enum Diff {
    Unmodified,
    Modified,
}

impl Diff {
    fn to_modified(self) -> Self {
        Diff::Modified
    }
}

// 定义 `Scope` 枚举，用于表示文件标签的作用域（公共或私有）
#[derive(Debug)]
enum Scope {
    Private,
    Public,
}

impl Scope {
    fn to_public(self) -> Self {
        Scope::Public
    }

    fn to_private(self) -> Self {
        Scope::Private
    }
}

// `FileTag` 结构体包含文件标签的各种属性
#[derive(Debug)]
struct FileTag {
    color: String,
    name: String,
    operator: Option<u64>,
    user_id: u64,
    diff: Diff,
    scope: Scope,
}

// 实现 `FileTag` 的功能
impl FileTag {
    // 定义一个默认颜色
    pub const DEFAULT_COLOR: &'static str = "#f6f8fa";

    // 返回一个构建器实例
    pub fn builder() -> FileTagBuilder {
        FileTagBuilder::default()
    }

    // 更改操作者
    pub fn change_operator(&mut self, operator: u64) -> UserFileResult<()> {
        self.diff = self.diff.to_modified();
        self.operator = Some(operator);
        self.validate()?;
        Ok(())
    }

    // 更改颜色（需要权限验证）
    pub fn change_color(&mut self, color: String, user_id: u64) -> UserFileResult<()> {
        if user_id != self.user_id {
            return Err(UserFileError::PermissionDenied);
        }
        self.diff = self.diff.to_modified();
        self.color = color;
        self.validate()?;
        Ok(())
    }

    // 更改名称（需要权限验证）
    pub fn change_name(&mut self, name: String, user_id: u64) -> UserFileResult<()> {
        if user_id != self.user_id {
            return Err(UserFileError::PermissionDenied);
        }
        self.diff = self.diff.to_modified();
        self.name = name;
        self.validate()?;
        Ok(())
    }

    // 切换到公共作用域
    pub fn change_to_public_scope(&mut self) -> UserFileResult<()> {
        self.diff = self.diff.to_modified();
        self.scope = self.scope.to_public();
        self.validate()?;
        Ok(())
    }

    // 切换到私有作用域
    pub fn change_to_private_scope(&mut self) -> UserFileResult<()> {
        self.diff = self.diff.to_modified();
        self.scope = self.scope.to_private();
        self.validate()?;
        Ok(())
    }

    // 验证函数，假设它检查某些条件以确保数据的有效性
    fn validate(&self) -> UserFileResult<()> {
        if self.name.is_empty() {
            return Err(UserFileError::ValidationError);
        }
        Ok(())
    }
}

// `FileTagBuilder` 结构体用于简化 `FileTag` 的创建
#[derive(Default)]
struct FileTagBuilder {
    color: String,
    name: String,
    user_id: u64,
    scope: Scope,
}

impl FileTagBuilder {
    pub fn color(mut self, color: String) -> Self {
        self.color = color;
        self
    }

    pub fn name(mut self, name: String) -> Self {
        self.name = name;
        self
    }

    pub fn user_id(mut self, user_id: u64) -> Self {
        self.user_id = user_id;
        self
    }

    pub fn scope(mut self, scope: Scope) -> Self {
        self.scope = scope;
        self
    }

    pub fn build(self) -> FileTag {
        FileTag {
            color: self.color,
            name: self.name,
            operator: None,
            user_id: self.user_id,
            diff: Diff::Unmodified,
            scope: self.scope,
        }
    }
}

fn main() {
    // 使用构建器模式创建 `FileTag` 实例
    let file_tag = FileTag::builder()
        .color("#f6f8fa".to_string())
        .name("My File".to_string())
        .user_id(1)
        .scope(Scope::Private)
        .build();

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

// `FileTagBuilder` 结构体用于简化 `FileTag` 的创建
#[derive(Default)]
struct FileTagBuilder {
    color: String,
    name: String,
    user_id: u64,
    scope: Scope,
}

impl FileTagBuilder {
    pub fn color(mut self, color: String) -> Self {
        self.color = color;
        self
    }
}

FileTagBuilder::color();

// Debug Clone Copy PartialEq
// 层级
#[derive(Debug, Clone, Copy)]
enum Race {
    White,
    Yellow,
    Black,
}
impl PartialEq for Race {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Race::White, Race::White) => true,
            (Race::Yellow, Race::Yellow) => true,
            (Race::Black, Race::Black) => true,
            _ => false,
        }
    }
}

#[derive(Debug, Clone)]
struct User {
    id: u32,
    name: String,
    race: Race,
}

impl PartialEq for User {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id && self.name == other.name && self.race == other.race
    }
}

fn main() {
    let user = User {
        id: 3,
        name: "John".to_owned(),
        race: Race::Yellow,
    };
    println!("{:#?}", user);
    let user2 = user.clone();
    println!("{:#?}", user2);
    println!("{}", user == user2);
}

loop {
   println!("Hello, world!");
   std::thread::sleep(std::time::Duration::from_secs(1));)
}

let numbers = [1, 2, 3, 4, 5].to_vec();
for i in 0..numbers.len() {
    println!("{}", numbers[i]);
}

for i in 0..=numbers.len() {
    println!("{}", numbers[i]);
}

let numbers = [1, 2, 3, 4, 5].to_vec();
let numbers = numbers.iter().map(|x| x * 2).collect::<Vec<_>>();

for (index, &item) in array.iter().enumerate() {
    if item == target {
        return Some(index);
    }
}

let vec = vec![1, 2, 3];
let iter = vec.into_iter(); // vec 被转换为一个迭代器，vec 本身被消耗

// 这样就可以使用迭代器的函数了

pub trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}

let vec = vec![1, 2, 3];
let iter = vec.iter(); // 获取一个不可变引用的迭代器，vec 本身没有被消耗

fn main() {
    // vec
    let v = vec![1, 2, 3, 4, 5]; // intoIterator 特质 into_iter
                                 // 转换为迭代器
    let iter = v.into_iter(); // move 所有权转移 类似ppt中的Iter Iterator的特质对象
    let sum: i32 = iter.sum();
    println!("sum: {}", sum);
    // println!("{:?}", v)
    // array
    let array = [1, 2, 3, 4, 5];
    let iter: std::slice::Iter<'_, i32> = array.iter();
    let sum: i32 = iter.sum();
    println!("sum: {}", sum);
    println!("{:?}", array);
    // chars
    let text = "hello, world!";
    let iter = text.chars();
    let uppercase = iter.map(|c| c.to_ascii_uppercase()).collect::<String>();
    println!("uppercase: {}", uppercase);
    println!("{:?}", text);
}

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

fn main() {
    thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }
}

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

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..5 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    handle.join().unwrap();

    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }
}

use std::thread;

fn main() {
    let v = vec![1, 2, 3];

    let handle = thread::spawn(|| {
        println!("Here's a vector: {:?}", v);
    });

    handle.join().unwrap();
}

use std::thread;

fn main() {
    let v = vec![1, 2, 3];

    let handle = thread::spawn(|| {
        println!("Here's a vector: {:?}", v);
    });

    drop(v); // oh no!

    handle.join().unwrap();
}

use std::thread;

fn main() {
    let v = vec![1, 2, 3];

    let handle = thread::spawn(move || {
        println!("Here's a vector: {:?}", v);
    });

    handle.join().unwrap();

    // 下面代码会报错borrow of moved value: `v`
    // println!("{:?}",v);
}

#[derive(Debug)]
struct User {
    name: String,
    score: u64,
}
// sort_by_key
// fn sort_score(users: &mut Vec<User>) {
//     users.sort_by_key(sort_helper);
// }

// fn sort_helper(u: &User) -> u64 {
//     u.score
// }
fn sort_score_closure(users: &mut Vec<User>) {
    users.sort_by_key(|u| u.score);
}

fn main() {
    let f = |a, b| a + b;
    println!("{}", f(1.0, 2.0));

    let a = User {
        name: "U1".to_owned(),
        score: 100,
    };
    let b = User {
        name: "U2".to_owned(),
        score: 80,
    };
    let c = User {
        name: "U3".to_owned(),
        score: 40,
    };
    let d = User {
        name: "U4".to_owned(),
        score: 90,
    };
    let mut users = vec![a, b, c, d];
    // sort_score(&mut users);
    sort_score_closure(&mut users);
    println!("{:?}", users);
}

fn main() {
    // Fn不可变引用获取外部参数
    let s1 = String::from("1111111111111111111");
    let s2 = String::from("2222222222222222222");
    let fn_func = |s| {
        println!("{s1}");
        println!("I am {s}");
        println!("{s1}");
    };
    fn_func("yz".to_owned());
    fn_func("原子".to_owned());
    println!("{s1} {s2}");

    // FnMut 可变引用获取外部参数
    let mut s1 = String::from("1111111111111111111");
    let mut s2 = String::from("2222222222222222222");
    let mut fn_func = |s| {
        s1.push_str("😀");
        s2.push_str("😀");
        println!("{s1}");
        println!("I am {s}");
        println!("{s1}");
    };
    fn_func("yz".to_owned());
    fn_func("原子".to_owned());
    println!("{s1} {s2}");
    // 所有权转移 由编译器根据我们的代码来判读
    // 非强制
    let s1 = String::from("1111");
    let fn_Once_func = || {
        println!("{s1}");
        std::mem::drop(s1);
    };
    fn_Once_func();
    // println!("{s1}");
    // 强制
    let s1 = String::from("1111");
    let move_fn = move || {
        println!("{s1}");
    }; // Fn : FnMut : FnOnce
    move_fn();
    // println!("{s1}");
    let s1 = String::from("1111");
    std::thread::spawn(move || println!("d  {s1}"));
}

// 宏的定义
macro_rules! add {
    // 匹配 2 个参数，如add!(1,2), add!(2,3)
    ($a:expr,$b:expr) => {
        // macro 宏展开的代码
        {
            // 表达式相加
            $a + $b
        }
    };

    // 匹配 1 个参数，如 add!(1), add!(2)
    ($a:expr) => {{
        $a
    }};
}

fn main() {
    let x = 0;
    // 宏的使用
    add!(1, 2);
    add!(x);
}

// 宏展开的代码如下
fn main() {
    {
        1 + 2
    }
}

macro_rules! add {
    ($a:expr,$b:expr) => {{
        $a + $b
    }};
}

macro_rules! add_as {
    // ty 表示参数类型
    ($a:expr,$b:expr,$typ:ty) => {
        $a as $typ + $b as $typ
    };
}

fn main() {
    // 这里 add! 宏可以使用多种数据类型
    println!("{}", add_as!(0, 2, u8));
    println!("{}", add_as!(0, 2, u16));
}

macro_rules! add{
    // 匹配单个参数
    ($a:expr)=>{
       $a
    };
   // 匹配2个参数
    ($a:expr,$b:expr)=>{
       {
           $a+$b
       }
    };
   // 递归调用
    ($a:expr,$($b:tt)*)=>{
        {
            $a+add!($($b)*)
        }
    }
}

fn main() {
    println!("{}", add!(1, 2, 3, 4));
}

use proc_macro::TokenStream;

// 标记类宏的类型
#[proc_macro_derive(CustomMacro)]
pub fn custom_macro_derive(input: TokenStream) -> TokenStream {
    TokenStream::new()
}

struct Foo { x: i32, y: i32 }

// 方式一
impl Copy for Foo { ... }
impl Clone for Foo { ... }
impl Ord for Foo { ... }
impl PartialOrd for Foo { ... }
impl Eq for Foo { ... }
impl PartialEq for Foo { ... }
impl Debug for Foo { ... }
impl Hash for Foo { ... }

// 方式二
#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug, Hash, Default)]
struct Foo { x: i32, y: i32 }

// 这是一个通用的 Trait 特征
trait HelloMacro {
    fn hello_macro();
}

// 自定义结构体 MyStruct，并实现如上特征
struct MyStruct;
impl HelloMacro for MyStruct {
    fn hello_macro() {
        println!("Hello, Macro! My name is MyStruct!");
    }
}

// 自定义结构体 YourStruct，并实现如上特征
struct YourStruct;
impl HelloMacro for YourStruct {
    fn hello_macro() {
        println!("Hello, Macro! My name is YourStruct!");
    }
}

fn main() {
    MyStruct::hello_macro();
    YourStruct::hello_macro();
}

// 引入宏相关的依赖
extern crate proc_macro;
use proc_macro::TokenStream;
use quote::quote;
use syn;
use syn::DeriveInput;

// HelloMacro 宏的实现逻辑
#[proc_macro_derive(HelloMacro)]
pub fn hello_macro_derive(input: TokenStream) -> TokenStream {
    let ast:DeriveInput = syn::parse(input).unwrap();
    impl_hello_macro(&ast)
}

DeriveInput {
    // --snip--
    vis: Visibility,
    ident: Ident {
        ident: "MyStruct",
        span: #0 bytes(95..103)
    },
    generics: Generics,
    
    // Data是一个枚举，分别是DataStruct，DataEnum，DataUnion，这里以 DataStruct 为例
    data: Data(
        DataStruct {
            struct_token: Struct,
            fields: Fields,
            semi_token: Some(
                Semi
            )
        }
    )
}

fn impl_hello_macro(ast: &syn::DeriveInput) -> TokenStream {
    
    let name = &ast.ident;
    let gen = quote! {
                // 实现 HelloMacro 特征
        impl HelloMacro for #name {
            fn hello_macro() {
                println!("Hello, Macro! My name is {}!", stringify!(#name));
            }
        }
    };
    gen.into()
}

#[derive(HelloMacro)]
struct MyStruct;

// HelloMacro 宏的定义
extern crate proc_macro;
use proc_macro::TokenStream;
use quote::quote;
use syn;
use syn::DeriveInput;

#[proc_macro_derive(HelloMacro)]
pub fn hello_macro_derive(input: TokenStream) -> TokenStream {

    let ast:DeriveInput = syn::parse(input).unwrap();

    impl_hello_macro(&ast)

}

fn impl_hello_macro(ast: &syn::DeriveInput) -> TokenStream {
    
    let name = &ast.ident;
    let gen = quote! {
                // 派生宏所实现的特征
        impl HelloMacro for #name {
            fn hello_macro() {
                println!("Hello, Macro! My name is {}!", stringify!(#name));
            }
        }
    };
    gen.into()
}


// 宏的使用
#[derive(HelloMacro)]
struct MyStruct;

#[derive(HelloMacro)]
struct YourStruct;

fn main() {
    println!("Hello, world!");
    MyStruct::hello_macro();
    YourStruct::hello_macro();
}

use proc_macro::TokenStream;

// 这里标记宏的类型
#[proc_macro_attribute]
pub fn custom_attribute(input: TokenStream, annotated_item: TokenStream) -> TokenStream {
    annotated_item
}

// 用于根据条件选择性地包含或排除代码
#[cfg(feature = "some_feature")]
fn conditional_function() {
    // 仅在特定特性启用时才编译此函数
}

#[test]
fn my_test() {
    // 测试函数
}

#[allow(unused_variables)]
fn unused_variable() {
    // 允许未使用的变量
}

use proc_macro::TokenStream;

// 这里标记宏的类型
#[proc_macro]
pub fn custom_fn_macro(input: TokenStream) -> TokenStream {
    input
}