let b = Box::new(1);

//Rc::clone 只会增加引用计数, 这样a,b都是指向1
 let a = Rc::new(1);
 let b = Rc::clone(&a);

// 在任意给定时刻，只能拥有一个可变引用或任意数量的不可变引用 之一（而不是两者）。
//引用必须总是有效的。

    let num = 1;
    let r1 = RefCell::new(1);
    // Ref - 只有一个不可变借用
    let r2 = r1.borrow();
    // RefMut - mutable  可变借用
    let r3 = r1.borrow_mut();
    // RefMut - 可变借用
    let r4 = r1.borrow_mut();

#[derive(Debug)]
enum List {
    Cons(Rc<RefCell<i32>>, Rc<List>),
    Nil,
}

use crate::List::{Cons, Nil};
use std::cell::RefCell;
use std::rc::Rc;

fn main() {
    let value = Rc::new(RefCell::new(5));

    let a = Rc::new(Cons(Rc::clone(&value), Rc::new(Nil)));

    let b = Cons(Rc::new(RefCell::new(3)), Rc::clone(&a));
    let c = Cons(Rc::new(RefCell::new(4)), Rc::clone(&a));

    *value.borrow_mut() += 10;

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

fn some_function() {}
mod outer_module {
    // private module
    pub mod inner_module {
        // public module
        pub fn inner_public_function() {
            super::super::some_function();
        }
        fn inner_private_function() {}
    }
}
fn main() {
    // 绝对路径 从 crate 根开始，以 crate 名或者字面值 crate 开头。
    crate::outer_module::inner_module::inner_public_function();
    //  相对路径（relative path）从当前模块开始，以 self、super 或当前模块的标识符开头。
    outer_module::inner_module::inner_public_function();
    // 使用 use 关键字将路径引入作用域
    use outer_module::inner_module;
    inner_module::inner_public_function();
}