Rust中的一些标准库

fn main() {
    let b = Box::new(5);
    println!("b = {}", b);
}

// 场景1：当有一个在编译时未知大小的类型，而又想要在需要确切大小的上下文中使用这个类型值的时候
// 例如递归的类型，自己可以包含自己
// ConsList 每一项包含两个元素：当前项和下一项，若为Nil则是结束项
// ConsList(0, ConsList(1, ConsList(2, Nil)))
enum List {
    Cons(i32, Box<List>),
    Nil,
}

fn example1() {
    let list = List::Cons(0, Box::new(List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))))));
}

// 场景2：当有大量数据并希望在确保数据不被拷贝的情况下转移所有权的时候
fn example2() {
    let a = [0; 1024 * 512];
    let a_box = Box::new(a);
    // 这两种写法等价，都会先在栈上分配数据，然后再拷贝数据到堆上，不过后面再转移所有权时不会再拷贝数据，只会转移地址
    let a_box2 = Box::new([0; 1024 * 512]);
}

// 场景3：当希望拥有一个值并只关心它的类型是否实现了特定 trait 而不是其具体类型的时候
fn example3() -> Result<(), Box<dyn std::error::Error>>{
    let f = std::fs::read("/tmp/not_exist")?;
    Ok(())
}

0 -> 1 \
        |-> 4
2 -> 3 /

use std::rc::Rc;

enum List2 {
    Cons(i32, Rc<List2>),
    Nil,
}

fn rc_example() {
    // 通过Rc可以实现一个值可以有多个所有者
    let four = Rc::new(List2::Cons(4, Rc::new(List2::Nil)));
    // 调用 clone 时，Rc的引用计数会加一
    let zero_one = List2::Cons(0, Rc::new(List2::Cons(1, four.clone())));
    // 另一种等价写法
    // let zero_one = List2::Cons(0, Rc::new(List2::Cons(1, Rc::clone(&four))));
    let two_three = List2::Cons(2, Rc::new(List2::Cons(3, four)));
}

fn main() {
    let mut v: Vec<i32> = Vec::new();
    v.push(1);
    println!("{:?}", v[0]);

    // 通过宏创建Vector的写法
    let v2: Vec<i32> = vec![0, 1, 2, 3, 4, 5];
    println!("{:?}", v2[2]);

    // 修改Vector内的元素值
    for e in v.iter_mut() {
        *e *= 2;
    }
}

use std::collections::HashMap;

fn main() {
    let map = HashMap::new();
    map.insert("key", "value");
    println!("{:?}", map.get(&"key"));
    map.remove(&"key");

    for (&k, &v) in map.iter() {
        println!("{:?} {:?}", k, v);
    }
}

fn  main() {

    let  s  =  "Hello World!";

    // "Hello World!" 是字符串字面量, 它直接存储在二进制文件中. 我们无法直接操作这些数据,
    // 必须借由 &str, 即它的引用来与之交互. 由于 "Hello World!" 存在二进制文件中, 因此它
    // 具有静态生命周期: 它在程序的整个运行期间都有效.

    // 变量 s 的类型是 &str, 表明它是 str 的一个引用. 但 str 是什么? str 是存储在内存中的
    // 字符串数据. 这里的内存可以是栈, 可以是堆, 也可以是数据段(二进制文件中). &str 是对 str
    // 的引用.

    let  t  =  String::from(s);

    // t 的类型是 String. String 存在堆中, 是一个可增长的缓冲区, 它拥有它的数据, 因此我们
    // 可以修改 t 的内容.

}

use std::thread::sleep;
use std::time::{Duration, SystemTime};

fn main() {
    // 获取当前时间
    let mut now = SystemTime::now();
    println!("{:?}", now);

    // 获取 UNIX TIMESTAMP
    let timestamp = now.duration_since(SystemTime::UNIX_EPOCH);
    println!("{:?}", timestamp);

    sleep(Duration::from_secs(4));

    // 获取流逝的时间
    println!("{:?}", now.elapsed());

    // 时刻的增减
    now.checked_add(Duration::from_secs(60))
}