Rust 核心概念详解：所有权、Trait 与宏系统

// Rust 可以同时兼顾安全与性能
fn process_data(data: Vec<u8>) -> Vec<u8> {
    data.into_iter()
        .map(|b| b.wrapping_add(1))
        .collect()
}

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;           // 所有权 move 到 s2
    // println!("{}", s1); // 错误！s1 已失效
    println!("{}", s2);
} // s2 离开作用域，String 被释放

fn main() {
    let mut s = String::from("hello");
    
    let r1 = &s;       // 不可变借用
    let r2 = &s;       // ✅ 多个不可变借用允许
    // let r3 = &mut s; // ❌ 与不可变借用冲突
    println!("{} {}", r1, r2);
    
    let r3 = &mut s;   // ✅ 之前借用已结束
    r3.push_str(" world");
}

let x = 5;
let y = x;           // ✅ Copy trait：按位复制，x 仍可用

let s1 = String::from("hi");
let s2 = s1.clone(); // Clone trait：深拷贝，s1 仍可用

use std::rc::Rc;
use std::cell::RefCell;

let shared = Rc::new(RefCell::new(0));
let clone1 = Rc::clone(&shared);
let clone2 = Rc::clone(&shared);

*clone1.borrow_mut() += 1;
*clone2.borrow_mut() += 1;
println!("{}", shared.borrow()); // 2

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn first_word(s: &str) -> &str { /* 自动推断：输入和输出同生命周期 */ }
fn get_by_key<'a>(&'a self, key: &str) -> &'a Value { /* 输出绑定 self */ }

struct Parser<'a> {
    text: &'a str,
    pos: usize,
}

impl<'a> Parser<'a> {
    fn peek(&self) -> Option<&'a str> {
        self.text.get(self.pos..self.pos + 1)
    }
}

let s: &'static str = "编译期字符串"; // 存储在二进制中
// 或 Box::leak 产生的堆内存
let leaked: &'static str = Box::leak(String::from("hello").into_boxed_str());

trait Drawable {
    fn draw(&self);
    fn bounds(&self) -> (f64, f64, f64, f64) {
        (0.0, 0.0, 100.0, 100.0) // 默认实现
    }
}

struct Circle { radius: f64 }
impl Drawable for Circle {
    fn draw(&self) { println!("Drawing circle"); }
}

fn print_drawable<T: Drawable>(item: &T) {
    item.draw();
}

// 多约束
fn process<T: Drawable + Clone + Send>(item: T) {}

// where 子句（清晰表达复杂约束）
fn complex<T, U>(t: T, u: U)
where
    T: Drawable + Clone,
    U: std::fmt::Debug + Send,
{}

trait Iterator {
    type Item; // 关联类型
    fn next(&mut self) -> Option<Self::Item>;
}

struct Counter;
impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<Self::Item> { Some(1) }
}

fn draw_all(items: &[Box<dyn Drawable>]) {
    for item in items { item.draw(); }
}

// dyn Trait 是 unsized，必须用指针包装（Box/Rc/&）

#[derive(Debug, Clone, PartialEq, Default)]
struct Point { x: f64, y: f64 }

struct Stack<T> {
    items: Vec<T>,
}

impl<T> Stack<T> {
    fn new() -> Self { Stack { items: Vec::new() } }
    fn push(&mut self, item: T) { self.items.push(item); }
    fn pop(&mut self) -> Option<T> { self.items.pop() }
}

struct Matrix<T, const N: usize, const M: usize> {
    data: [[T; M]; N],
}

let m: Matrix<f64, 3, 3> = Matrix { data: [[0.0; 3]; 3] };

fn max<T: PartialOrd>(a: T, b: T) -> T {
    if a > b { a } else { b }
}

// 编译后生成：
// fn max_i32(a: i32, b: i32) -> i32 { ... }
// fn max_f64(a: f64, b: f64) -> f64 { ... }

macro_rules! vec_str {
    ($($x:expr),*) => {
        {
            let mut temp_vec = Vec::new();
            $(temp_vec.push($x.to_string());)*
            temp_vec
        }
    };
}

let v = vec_str!["hello", "world"];

// derive 宏（#[derive(MyTrait)]）
#[proc_macro_derive(MyTrait)]
pub fn my_trait_derive(input: TokenStream) -> TokenStream { ... }

// 属性宏（#[my_attribute]）
#[proc_macro_attribute]
pub fn my_attribute(args: TokenStream, input: TokenStream) -> TokenStream { ... }

// 函数式宏（my_macro!()）
#[proc_macro]
pub fn my_macro(input: TokenStream) -> TokenStream { ... }

# Cargo.toml（根）
[workspace]
members = ["api", "core", "cli"]
resolver = "2"

[workspace.dependencies]
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }

[features]
default = ["serde"]
serde = ["dep:serde"]
async = ["tokio", "futures"]

#[cfg(feature = "serde")]
impl serde::Serialize for MyType { ... }

cargo add tokio --features full    # 添加依赖
cargo tree                         # 查看依赖树
cargo audit                        # 安全审计
cargo clippy -- -D warnings        # 静态分析
cargo test --lib                   # 仅运行单元测试