#[derive(Debug)]
enum MyList {
    Cons(i32, Box<MyList>), // 必須為Box，此處為遞歸，大小不確定
    Nil,
}
use MyList::{Cons, Nil};
let list = Cons(1, Box::new(Cons(2, Box::new(Nil))));
println!("Recursive list: {:?}", list);

// 定義trait
trait Shape {
    fn area(&self) -> f64;
}
// 實現(xiàn)trait的結(jié)構(gòu)體
struct Circle { radius: f64 }
impl Shape for Circle {
    fn area(&self) -> f64 { std::f64::consts::PI * self.radius.powf(2.0) }
}
struct Square { side: f64 }
impl Shape for Square {
    fn area(&self) -> f64 { self.side.powf(2.0) }
}
fn main() {
    // 用Box<dyn Shape>存儲不同類型的Shape實現(xiàn)
    let shapes: Vec<Box<dyn Shape>> = vec![
        Box::new(Circle { radius: 1.0 }),
        Box::new(Square { side: 2.0 }),
    ];
    // 動態(tài)調(diào)用area方法（運(yùn)行時確定具體類型）
    for shape in shapes {
        println!("面積：{:.2}", shape.area()); 
        // 輸出：3.14（圓）、4.00（正方形）
    }
}

use std::rc::Rc;
fn main() {
    let a = Rc::new(String::from("hello"));
    let b = Rc::clone(&a);
    let c = Rc::clone(&a);
    println!("count = {}", Rc::strong_count(&a)); // 輸出 3
    println!("{}", b);
} // 所有 Rc 離開作用域后才釋放堆內(nèi)存

use std::sync::Arc;
use std::thread;
pub fn arc_test() {
    let data = Arc::new(100); // 堆上的數(shù)據(jù)，原子引用計數(shù)=1
    let mut handles = vec![];
    // 創(chuàng)建3個線程共享data
    for i in 0..3 {
        let d = Arc::clone(&data); // 計數(shù)+1（原子操作）
        handles.push(thread::spawn(move || {
            println!("i: {}", d);
        }));
    }
    println!("before ref-count: {:?}", Arc::strong_count(&data));
    for h in handles {
        h.join().unwrap();
    }
    println!("after ref-count: {:?}", Arc::strong_count(&data)); // 原子引用計數(shù)=1
}

use std::rc::Rc;
use std::cell::RefCell;
pub fn refcell_test() {
    let shared_data = Rc::new(RefCell::new(0)); // 堆上的0，可共享且修改
    let a = Rc::clone(&shared_data);
    let b = Rc::clone(&shared_data);
    *a.borrow_mut() += 10; // a修改數(shù)據(jù)
    *b.borrow_mut() += 5; // b修改數(shù)據(jù)
    println!("{}", shared_data.borrow()); // 輸出15
}

use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    for _ in 0..5 {
        let c = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            let mut num = c.lock().unwrap();
            *num += 1;
        }));
    }
    for h in handles {
        h.join().unwrap();
    }
    println!("Result: {}", *counter.lock().unwrap());
}

use std::sync::RwLock;
use std::thread;
let data = RwLock::new(0);
// 啟動一個寫線程
let w_handle = thread::spawn(move || {
    let mut w = data.write().unwrap();
    thread::sleep(std::time::Duration::from_millis(100));
    *w = 42;
});
// 啟動多個讀線程
let mut r_handles = vec![];
for _ in 0..3 {
    let r_data = data.clone();
    let handle = thread::spawn(move || {
        let r = r_data.read().unwrap(); // 會被寫線程阻塞，直到寫完成
        println!("Read: {}", *r);
    });
    r_handles.push(handle);
}
w_handle.join().unwrap();
for h in r_handles { h.join().unwrap(); }

enum Cow<'a, B: ?Sized + 'a> where B: ToOwned {
    Borrowed(&'a B),
    Owned(<B as ToOwned>::Owned),
}

use std::borrow::Cow;
fn main() {
    let s = "immutable data".to_string();
    let mut cow = Cow::Borrowed(s.as_str()); // 借用 &str
    println!("Before: {:?}", cow); // Borrowed("immutable data")
    // 調(diào)用 to_mut() 會檢測當(dāng)前是否為借用
    let data = cow.to_mut(); // 克隆一份（從 Borrowed -> Owned）
    data.push_str(" modified");
    println!("After: {:?}", cow);  // Owned("immutable data modified")
}

use std::pin::Pin;
struct SelfRef {
    data: String,
    ptr: *const String,
}
impl SelfRef {
    fn new(txt: &str) -> Pin<Box<SelfRef>> {
        let mut boxed = Box::pin(SelfRef {
            data: String::from(txt),
            ptr: std::ptr::null(),
        });
        let ptr = &boxed.data as *const String;
        unsafe {
            let mut_ref = Pin::as_mut(&mut boxed);
            Pin::get_unchecked_mut(mut_ref).ptr = ptr;
        }
        boxed
    }
    fn show(&self) {
        unsafe {
            println!("data = {}, ptr = {}", self.data, &*self.ptr);
        }
    }
}
fn main() {
    let pinned = SelfRef::new("hello");
    pinned.show();
}