# 安装 rustup
curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
# 验证是否安装成功
rustc --version
# 更新 rust 版本
rustup update
# 更新 rustup
rustup self update
# 卸载 rust
rustup self uninstall
# 打开本地 rust 文档
rustup doc

cargo --version
# 创建项目
# --lib 库项目
# --vcs=git 指定版本控制工具
cargo new demo
# 编译, --release 发布时编译
cargo build
# 清除 cargo 构建文件
cargo clean
# 检查代码 (不生成可执行文件)
cargo check
# 编译并运行
cargo run
# 安装二进制文件
cargo install <crate-name> # 会安装到 ～/.cargo/bin
cargo install --force <crate-name> # 重新安装
# 生成文档并打开
cargo doc --open
# 发布 crate
cargo publish
cargo yank # 撤回版本

# cargo 常用的第三方插件, 需要 cargo install 这些插件才可运行
# 自动修复 warning
cargo fix
# 添加项目依赖
cargo add
# 审核项目依赖是否有漏洞风险
cargo audit
# lint 工具
cargo clippy
# 格式化代码
cargo fmt
# 可展开宏代码, 方便调试
cargo expand

// 单行注释
/**
    多行注释
*/

//! 这是一个模块级别的文档注释

/// 这是一个函数的文档注释 (可使用 markdown 语法)
/// 可以使用 cargo doc --open 生成文档
/// 
/// # Examples
/// ```
/// // 编写一些示例 (运行 cargo test 的时候，会把示例的代码作为测试来运行)
/// let arg = 5;
/// let answer = add_one(arg);
/// assert_eq!(6, answer);
/// ```
/// 
/// # Panics
/// 说明函数可能发生 panic 的场景
/// 
/// # Errors
/// 如果函数返回 Result，描述可能的错误种类，以及可导致错误的条件
/// 
/// # Safety
/// 如果函数处于 unsafe 调用，就应该解释 unsafe 的原因，以及调用者确保的使用前提
pub fn add_one(x: i32) -> i32 {
    x + 1
}

// print!、println!、eprint!、eprintln!
println!("{}", 2);
println!("{0}, this is {1}. {1}, this is {0}", "Alice", "Bob");
println!("{a} {b} {c}", a="a", b="b", c="c");

let x: u32 = 5; // 在栈上分配一个类型为 u32 的变量, 变量名为 x
x = 6; // Error: cannot assign twice to immutable variable

let mut y = 5;
y = 6; // OK
y = "y"; // 类型错误

// shadow
let x = 5;
let x = x + 1;
let x = "x";

// 解构
let (mut a, mut b) = (1, 2);
let Point { x: ref a, y: ref b } = p;

const MAX_POINTS: u32 = 100_1000;

// 全局变量
// 声明时必须初始化，且初始化必须为编译期可确定的常量
// 全局变量读写时需要用 unsafe 修饰
static GLOBAL: i32 = 0; // 生命周期('static)为整个程序运行期间

// 使用静态变量时, 由于一些限制, 可以使用 lazy_static 工具
// https://github.com/rust-lang-nursery/lazy-static.rs
static MAP: HashMap<String, String> = HashMap::new(); // 无法编译通过, 需要用 lazy_static

use lazy_static::lazy_static;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};

lazy_static! {
    static ref HASHMAP: Arc<Mutex<HashMap<u32, &'static str>>> = {
        let mut m = HashMap::new();
        m.insert(0, "foo");
        m.insert(1, "bar");
        m.insert(2, "baz");
        Arc::new(Mutex::new(m))
    };
}

fn main() {
    let mut map = HASHMAP.lock().unwrap();
    map.insert(3, "waz");

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

let guess: u32 = "42".parse().expect("Not a number");

let x = 2.0; // f64
let y: f32 = 3.0; // f32

let a = 5 + 10;
let b = 3.2 - 2.1;
let c = 2 * 3;
let d = 30 / 3;
let e = 54 % 5;

let x = 'z';
let y: char = '『';
let z = '😄';

use std::char;

fn main() {
    let tao = '道';
    let tao_u32 = tao as u32;
    assert_eq!(36947, tao_u32);
    println!("U+{:x}", tao_u32); // U+9053
    println!("{}", tao.escape_unicode()); // \u{9053}
    assert_eq!(char::from(65), 'A');
    assert_eq!(char::from_u32(0x9053), Some('道'));
    assert_eq!(char::from_u32(36947), Some('道'));
    assert_eq!(char::from_u32(129010101), None);
}

let tup: (i32, f64, u8) = (500, 6.4, 1);
println!("{} {} {}", tup.0, tup.1, tup.2);
// 使用模式匹配结构 tuple
let (x, y, z) = tup;

// Empty Tuple (Unit 类型)
let empty: () = (); // 空元组占用 0 内存空间

let a = [1, 2, 3];
// 数组的类型 [类型; 长度]
let b: [u32; 2] = [1, 2];

// 如果数组中每个元素值都相同可以这样声明
let c = [3; 5]; // 相当于 let c = [3, 3, 3, 3, 3];

// 访问数组元素
// - 如果索引超出数组范围，编译会报错
// - 如果索引是动态的，那么编译会通过，运行时会报错
let d = c[0];

let guess: u32 = match guess.trim().parse() {
    Ok(num) => num,
    // continue 返回 never 类型, never 可强转为任何其他类型,
    // 所以该分支可以使用 continue 作为 u32 类型
    Err(_) => continue,
};

fn bar() -> ! {
    loop {} // 此处永远没有返回值, 所以类型为 never
}

impl<T> Option<T> {
    pub fn unwrap(self) -> T {
        match self {
            Some(val) => val,
            // panic 是 never, 所以可以作为 T 使用
            None => panic!("called `Option::unwrap()` on a `None` value"),
        }
    }
}

fn foo<T>(x: T) -> T {
    return x;
}

assert_eq!(foo(1), 1);
assert_eq!(foo("abc"), "abc");

// rust 如果类型推断失败，则需要手工指定类型
foo(1);     // 等价于 foo::<i32>(1);
foo("abc"); // 等价于 foo::<&'static str>("abc");

let v1: i8 = 41;
let v2: i16 = v1 as i16; // 也可 v1.into()

let i = 42;
let p = &i as *const i32 as *mut i32;
println!("{:?}", p);

type Age = u32;
type Double<T> = (T, Vec<T>);

let y = 6; // 语句
let x = (let y = 6); // 报错

let y = {
    let x = 1;
    x + 3 // 表达式产生的值 (不加分号, 加分号产生的值位 unit type)
};

// 分号表达式返回值永远为自身的单元 (Unit) 类型: `()`
// 分号表达式只有在块表达式最后一行才会进行求值，其他时候只作为连接符存在
// 块表达式只对其最后一行表达式进行求值
fn main() { // -> ()
    ; // 作为连接符
    ; // 作为连接符
    {
        ()
    }
    {
        ();
        use std:vec::Vec; // 以 ; 结尾，所以该块返回 () 类型
    }
    ();   // -> ()
    &{;}; // 块表达式最后一个分号返回 Unit，与 & 结合产生 &() 类型，该行最后一个分号是连接符
        ;
        ; // 作为 main 函数的返回值 ()
}
// 想获取 &() 类型，不能通过 `&;` 产生，因为不符合求值规则，这里的分号是作为连接符存在的
// 得通过 `&{;}` 分号作为块表达式的结尾才会使分号能够求值，产生 &() 类型

// 声明函数 (函数的定义也是语句)
fn test() {
    println!("test");
}
fn test2(x: i32, y: i32) {}
test2(5, 6);

// 返回值是函数体里最后一个表达式的值
// 如想提前返回，可以使用 return 关键字，指定一个值
fn test3(x: i32) -> i32 {
    x + 5
}
let x = test3(6); // 11

fn plus_one(i &u32) -> u32 {
    let i = i + 1;
    i // 不加分号，求值并返回 (如果加了分号，返回的是 Unit Type)
    // 也可使用 return 进行显示返回, 使用 return 时，末尾加不加分号都会返回表达式的值
}

let number = 6;
if number % 4 == 0 {
    println!("number is divisible by 4");
} else if number % 3 == 0 {
    println!("number is divisible by 3");
} else {
    println!("number is not divisible by 4 or 3");
}

// if 是表达式
let condition = true;
let number = if condition { 5 } else { 6 }; // 每个分支产生的值，类型必须一致

loop {
    println!("again!");
}

let mut counter = 0;
let result = loop {
    counter += 1;
    if counter == 10 {
        break counter * 2; // 作为表达式结果
    }
};

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

let mut number = 3;
while number != 0 {
    println!("{}", number);
    number = number - 1;
}

let a = [10, 20, 30, 40, 50];
for element in a {
    println!("the value is: {}", element);
}

let v = vec![10, 42, 9, 8];
for item in v {
    println!("{}", item);
}

let v = vec![10, 42, 9, 8];
for (index, value) in v.iter().enumerate() {
    println!("index: {}, value: {}", index, value);
}

for number in (1..4).rev() {
    println!("{}", number);
}
// rev 倒序循环
// 依次输出 3 2 1