cargo run --bin 00_cargo
cargo run --bin 01_variables
cargo run --bin 05_ownership
cargo run --bin 13_lifetimes
cargo run --bin 16_testing
cargo run --bin 21_project -- Cargo.toml

本课解决：（一句话）
我卡住的点：（一句话）
能复述的一句话：（一句话）

错误码/现象：
我原来的理解：
正确规则：
下次如何识别：

目标：我想让程序做什么
最小代码：删到能复现问题的最短版本
完整报错：从 error[...] 开始，不要只贴最后一行
已尝试：我查了什么、改了什么、结果如何

[package]
name = "rust"
version = "0.1.0"
edition = "2024"
rust-version = "1.99"
default-run = "rust"

[dependencies]

src/lib.rs              -> library crate（名字 rust）
src/main.rs             -> 默认 binary
src/bin/00_cargo.rs     -> binary target: 00_cargo
src/bin/01_variables.rs -> binary target: 01_variables

.
├── Cargo.toml
├── Cargo.lock
├── src
│   ├── main.rs
│   ├── lib.rs
│   └── bin
│       ├── 00_cargo.rs
│       └── 01_variables.rs
├── tests
│   └── integration_test.rs
├── examples
│   └── demo.rs
└── target

cargo add serde --features derive

[dependencies]
serde = { version = "1", features = ["derive"] }

[profile.release]
opt-level = 3
lto = "thin"
codegen-units = 1

[workspace]
members = ["app", "core", "cli"]
resolver = "2"

=== 1. 当前 package ===
name        = rust
version     = 0.1.0
edition     = 2024（见 Cargo.toml）
rust-version= 1.99
manifest    = /home/.../rust

=== 2. Cargo.toml（编译期嵌入） ===
[package]
name = "rust"
...

let x = 5;
println!("x = {x}");

// x = 6; // ❌ cannot assign twice to immutable variable

let mut y = 10;
y += 5;
y *= 2;
println!("y = {y}"); // 30

let mut n = 1;
// n = "hello"; // ❌ 类型不匹配

let spaces = "   ";          // &str
let spaces = spaces.len();   // usize，类型可以改变
println!("{spaces}");        // 3

let value = 1;
{
    let value = value * 10;
    println!("内层：{value}"); // 10
}
println!("外层：{value}"); // 1

const MAX_POINTS: u32 = 100_000;
const SECONDS_PER_DAY: u32 = 24 * 60 * 60;

static GREETING: &str = "hello";

// static mut COUNTER: u32 = 0;
// unsafe { COUNTER += 1; } // 不推荐

let guess: u32 = "42".parse().expect("不是数字");
let ratio = 1.5_f64;
let big = 1_000_000_u64;
let _unused = 2.5; // 下划线开头，避免未使用警告

=== 1. 不可变绑定（默认行为） ===
x = 5

=== 2. 用 mut 声明可变变量 ===
修改前：y = 10
修改后：y = 30

=== 3. 变量遮蔽（shadowing） ===
spaces = 3（类型已从 &str 变为 usize）

let dec = 98_222;        // 十进制
let hex = 0xff;          // 十六进制
let octal = 0o77;        // 八进制
let binary = 0b1111_0000;// 二进制
let byte = b'A';         // u8 字节字面量

let max = u8::MAX; // 255

max.wrapping_add(1);    // 0，回绕
max.checked_add(1);     // None
max.saturating_add(1);  // 255，饱和
max.overflowing_add(1); // (0, true)

let x: f64 = 2.0;
let y = 3.5_f32;

let sum: f64 = 0.1 + 0.2;
println!("{}", (sum - 0.3).abs() < 1e-9); // true

let tup: (i32, f64, char) = (500, 6.4, 'x');
let (a, b, c) = tup;          // 解构
println!("{}", tup.0);        // 索引访问

let arr: [i32; 5] = [1, 2, 3, 4, 5];
let zeros = [0u8; 4];         // 4 个 0
println!("{}", arr[0]);
println!("{}", arr.len());

let slice: &[i32] = &arr[1..4]; // 左闭右开
let text = "hello 世界";
let hello = &text[..5];
let world = &text[6..];

let big: i32 = 300;
println!("{}", big as u8);   // 44，截断
println!("{}", -1_i32 as u8); // 255
println!("{}", 3.99_f64 as i32); // 3，向零截断

let a: i64 = i64::from(42_i32);
let b: i64 = 42_i32.into();

let small = u8::try_from(300_i32); // Err(TryFromIntError)
let ok = u8::try_from(42_i32);     // Ok(42)

=== 1. 整数类型 ===
a = -42
b = 170 (0b1010_1010)
c = 493 (0o755)
d = 65535 (0xFF_FF)
e = 1000000
f = 340282366920938463463374607431768211455 (u128::MAX)
g = -1, h = 42
default_int 的类型是 i32：42

fn add(a: i32, b: i32) -> i32 {
    a + b
}

let y = {
    let x = 3;
    x * x // 没有分号，块的值是 9
};

let unit = {
    let x = 3;
    let _ = x * x; // 块仍然返回 ()
};

fn abs(n: i32) -> i32 {
    if n < 0 {
        return -n;
    }
    n
}

fn boom() -> ! {
    panic!("boom")
}

fn double(x: i32) -> i32 { x * 2 }

let f: fn(i32) -> i32 = double;
println!("{}", f(21));

fn apply(f: fn(i32) -> i32, x: i32) -> i32 {
    f(x)
}

fn factorial(n: u64) -> u64 {
    if n <= 1 { 1 } else { n * factorial(n - 1) }
}

fn outer() {
    fn square(n: i32) -> i32 { n * n }
    println!("{}", square(12));
}

const fn square_const(n: usize) -> usize { n * n }
const TABLE_SIZE: usize = square_const(8);

fn by_value(mut n: i32) -> i32 { n += 1; n }
fn by_ref(n: &mut i32) { *n += 1; }
fn by_str(s: &str) -> usize { s.len() }

// fn greet(name: &str) {}
// fn greet(name: &str, times: u32) {} // ❌ 不允许

=== 1. 基本函数 ===
add(2, 3) = 5
print_number: 7
print_number 的返回值是 ()

=== 2. 表达式 vs 语句 ===
块表达式的值 = 9
加分号后 = ()

let number = 7;
if number % 2 == 0 {
    println!("偶数");
} else {
    println!("奇数");
}

let desc = if number > 5 { "大于 5" } else { "不大于 5" };

let result = loop {
    break 42;
};

while countdown > 0 {
    countdown -= 1;
}

for i in 1..=5 {
    println!("{i}");
}

'outer: for i in 1..=5 {
    for j in 1..=5 {
        if i * j == 12 {
            break 'outer;
        }
    }
}

let mut stack = vec![1, 2, 3];
while let Some(top) = stack.pop() {
    println!("{top}");
}

if let Some(name) = maybe_name {
    println!("{name}");
}

for input in ["1", "不是数字"] {
    let Ok(value) = input.parse::<i32>() else {
        println!("解析失败");
        continue;
    };
    println!("{value}");
}

let label = match n {
    0 => "零",
    1..=9 => "个位数",
    x if x < 0 => "负数",
    _ => "大数",
};

=== 1. if 表达式 ===
7 是奇数
description = 大于 5

=== 2. else if ===
score = 86, grade = B

=== 3. loop：无限循环 + break 带值 ===
loop 的结果 = 50

let s1 = String::from("hello");
let s2 = s1; // s1 被移动

// println!("{s1}"); // ❌ borrow of moved value

let s3 = s2.clone();

let x = 5;
let y = x; // 按位复制，x 仍可用

fn take(s: String) { }        // 取得所有权
fn borrow(s: &str) { }        // 借用
fn change(s: &mut String) { } // 可变借用

let name = String::from("Ferris");
take(name);
// println!("{name}"); // ❌

let name2 = String::from("Ferris");
borrow(&name2);
println!("{name2}"); // ✅

let mut value = 10;

let r1 = &value;
let r2 = &value;
println!("{r1} {r2}");

// let r3 = &mut value; // ❌ 与 r1/r2 冲突

let r3 = &mut value; // ✅ r1/r2 最后一次使用之后
*r3 += 1;

let mut text = String::from("hello world");
let word = first_word(&text);
println!("{word}");

text.push_str("!"); // ✅ word 最后一次使用之后

{
    let temp = String::from("temp");
} // temp 在这里释放

let bye = String::from("bye");
drop(bye); // 提前释放

// let r;
// {
//     let s = String::from("short");
//     r = &s;
// }
// println!("{r}"); // ❌ s 已释放

=== 1. 栈与堆 ===
stack_num = 42（值直接在栈上）
heap_string = hello（栈上存指针/长度/容量，数据在堆上）

=== 2. 移动（move） ===
s2 = hello
移动后只有 s2 有效。

=== 3. 克隆（clone） ===

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

struct Color(i32, i32, i32); // 元组结构体

struct AlwaysEqual; // 单元结构体

let mut user = User {
    active: true,
    username: String::from("ferris"),
    email: String::from("ferris@rust-lang.org"),
    sign_in_count: 0,
};

user.sign_in_count += 1;

let username = String::from("crab");
let user1 = User {
    active: true,
    username, // 等价于 username: username
    email: String::from("crab@example.com"),
    sign_in_count: 0,
};

let user2 = User {
    email: String::from("new@example.com"),
    ..user1
};

// user1 的 username / email 已被移入 user2，不能再整体使用。
// 若想保留 user1，可为 User 加上 #[derive(Clone)]（derive 见 6.5），再写 ..user1.clone()。

impl User {
    fn new(username: &str, email: &str) -> Self {
        Self {
            active: true,
            username: username.to_string(),
            email: email.to_string(),
            sign_in_count: 0,
        }
    }

    fn display_name(&self) -> &str {
        &self.username
    }

    fn deactivate(&mut self) {
        self.active = false;
    }

    fn into_username(self) -> String {
        self.username
    }
}

impl Rectangle {
    fn area(&self) -> f64 { self.width * self.height }
}

impl Rectangle {
    fn perimeter(&self) -> f64 { 2.0 * (self.width + self.height) }
}

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

println!("{point:?}");   // 单行
println!("{point:#?}");  // 多行美化

=== 1. 定义与创建结构体 ===
user = User { active: true, username: "ferris", email: "ferris@rust-lang.org", sign_in_count: 0 }
登录次数：1

=== 2. 字段初始化简写 ===
user2 = User { active: true, username: "crab", email: "crab@example.com", sign_in_count: 0 }

=== 3. 结构体更新语法 ===
user3 = User { active: true, username: "crab", email: "new@example.com", sign_in_count: 0 }

enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

let home = IpAddr::V4(127, 0, 0, 1);
let loopback = IpAddr::V6(String::from("::1"));

enum Option<T> {
    Some(T),
    None,
}

enum Result<T, E> {
    Ok(T),
    Err(E),
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("来自 {state:?}");
            25
        }
    }
}

let n = 5;
let label = match n {
    0 => "零",
    1 | 2 | 3 => "小数字",
    4..=9 => "中等数字",
    x if x < 0 => "负数",
    _ => "大数字",
};
println!("{label}");

let age = 20;
match age {
    n @ 0..=12 => println!("儿童：{n}"),
    n @ 13..=19 => println!("青少年：{n}"),
    n => println!("成人：{n}"),
}

let (x, y) = (1, 2);

match point {
    Point { x: 0, y: 0 } => println!("原点"),
    Point { x, y: 0 } => println!("x 轴，x = {x}"),
    Point { x: 0, y } => println!("y 轴，y = {y}"),
    Point { x, y } => println!("({x}, {y})"),
}

let Point { x, .. } = point; // 只取 x

if let Some((host, port)) = config {
    println!("{host}:{port}");
}

// 下面这段假设位于循环体内
let Ok(id) = input.parse::<u32>() else {
    continue;
};

while let Some(top) = stack.pop() {
    println!("{top}");
}

println!("{}", matches!(coin, Coin::Quarter(_)));

let some = Some(10);
let none: Option<i32> = None;

some.map(|x| x * 2);          // Some(20)
none.unwrap_or(0);            // 0
none.unwrap_or_else(|| 42);   // 42
some.filter(|x| *x > 5);      // Some(10)
some.and_then(|x| Some(x + 1)); // Some(11)
none.ok_or("没有值");          // Err("没有值")

enum List {
    Cons(i32, Box<List>),
    Nil,
}

=== 1. 枚举基础 ===
IPv4: 127.0.0.1
IPv6: ::1

=== 2. 带数据的变体 ===
Quit
Move 到 (10, 20)
Write: hello
颜色改为 (255, 0, 0)

let mut v: Vec<i32> = Vec::new();
v.push(3);
v.push(1);

let v2 = vec![1, 2, 3];
let v3 = vec![0; 5];

println!("{}", v[0]);          // 越界会 panic
println!("{:?}", v.get(10));   // None，更安全

for x in &v {
    println!("{x}");
}

for x in &mut v {
    *x *= 10;
}

v.insert(0, 9);
v.remove(0);
v.pop();
v.sort();
v.dedup();
v.retain(|x| x % 2 == 0);
v.reverse();

let mut s = String::new();
s.push_str("hello");
s.push(' ');
s.push_str("world");

let s2 = format!("{s}!");
let s3 = String::from("Hello, ") + "Rust";

let text = String::from("hello 世界");
println!("{}", text.len());          // 字节数
println!("{}", text.chars().count()); // 字符数

let hello = &text[..5]; // ✅
// let bad = &text[..7]; // ❌ panic

use std::collections::HashMap;

let mut scores = HashMap::new();
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

let score = scores.get("Blue").copied().unwrap_or(0);

let mut counts = HashMap::new();
for word in text.split_whitespace() {
    *counts.entry(word).or_insert(0) += 1;
}

use std::collections::{BTreeMap, HashSet, VecDeque};

let a: HashSet<i32> = [1, 2, 3, 4].into_iter().collect();
let b: HashSet<i32> = [3, 4, 5].into_iter().collect();

a.intersection(&b);
a.union(&b);
a.difference(&b);

let mut btree = BTreeMap::new();
btree.insert(3, "three");
btree.insert(1, "one"); // 按 key 有序

let mut deque = VecDeque::from([2, 3]);
deque.push_front(1);
deque.push_back(4);

=== 1. Vec：创建与基本操作 ===
v = [3, 1, 4], len = 3, capacity = 4
v2 = [1, 2, 3]
v3 = [0, 0, 0, 0, 0]

=== 2. 索引 vs get ===
v[0] = 3
索引 10 越界，get 返回 None
v.get(2) = Some(4)

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {
            seat_at_table();
        }

        fn seat_at_table() { } // 私有
    }

    pub mod serving {
        pub fn take_order() {
            super::hosting::add_to_waitlist();
        }
    }
}

use front_of_house::{hosting, serving};
use std::collections::HashMap as Map;

hosting::add_to_waitlist();

mod api {
    pub use crate::front_of_house::hosting;
}

api::hosting::add_to_waitlist();

src/lib.rs
src/module_demo.rs
src/module_demo/greetings.rs
src/module_demo/math.rs
src/module_demo/math/advanced.rs

=== 1. 概念：package / crate / module ===
package  = Cargo.toml 描述的项目（可以含多个 crate）
crate    = 一次编译的单元：lib crate 或 bin crate
module   = crate 内的命名空间，用 mod 声明

本 package 包含：
  - library crate `rust`（src/lib.rs）
  - binary crate `09_packages_and_modules`（本文件）
  - 以及 src/bin/ 下的其他课程 binary crate

// panic!("something is wrong");

enum Result<T, E> {
    Ok(T),
    Err(E),
}

match divide(10.0, 2.0) {
    Ok(value) => println!("{value}"),
    Err(error) => println!("{error}"),
}

let result: Result<i32, &str> = Ok(42);
let value = result.unwrap();
println!("{value}");

let result: Result<i32, &str> = Ok(42);
let value = result.expect("这里不应该失败");
println!("{value}");

fn calc(x: f64) -> Result<f64, MathError> {
    let a = divide(10.0, x)?;
    let b = sqrt(a)?;
    Ok(b)
}

fn first_char(s: &str) -> Option<char> {
    let c = s.chars().next()?;
    Some(c.to_ascii_uppercase())
}

#[derive(Debug)]
enum AppError {
    EmptyInput,
    Parse(std::num::ParseIntError),
}

impl std::fmt::Display for AppError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            AppError::EmptyInput => write!(f, "输入不能为空"),
            AppError::Parse(e) => write!(f, "解析失败: {e}"),
        }
    }
}

impl std::error::Error for AppError {}

impl From<std::num::ParseIntError> for AppError {
    fn from(e: std::num::ParseIntError) -> Self {
        AppError::Parse(e)
    }
}

fn parse_len(input: &str) -> Result<usize, Box<dyn std::error::Error>> {
    let n: i32 = input.parse()?;
    Ok(n.unsigned_abs() as usize)
}

let found = find_user(1).ok_or("用户不存在");
let missing = find_user(2).ok_or_else(|| format!("id 2 不存在"));
let parsed: Result<i32, _> = "123".parse();
let option = parsed.ok();

let result: Result<i32, String> = Ok(21);
println!("{:?}", result.map(|x| x * 2)); // Ok(42)

let result: Result<i32, String> = Err("bad".into());
println!("{:?}", result.map_err(|e| format!("错误: {e}")));

let result: Result<i32, String> = Ok(21);
println!("{:?}", result.and_then(|x| Ok(x + 1))); // Ok(22)

let result: Result<i32, String> = Err("bad".into());
println!("{}", result.unwrap_or(0)); // 0

let result: Result<i32, String> = Err("bad".into());
println!("{}", result.unwrap_or_else(|e| e.len() as i32)); // 3

=== 1. panic!：不可恢复错误 ===
v.get(99).unwrap_or(&0) = 0（安全地处理越界）

=== 2. Result<T, E> ===
ok = Ok(42)
err = Err("出错了")

=== 3. 用 match 处理 Result ===
10 / 2 = 5

fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut largest = list[0];
    for &item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn new(x: T, y: T) -> Self {
        Self { x, y }
    }
}

impl Point<f64> {
    fn distance_from_origin(&self) -> f64 {
        (self.x * self.x + self.y * self.y).sqrt()
    }
}

struct Pair<T, U> {
    first: T,
    second: U,
}

fn make_pair<T, U>(a: T, b: U) -> (T, U) {
    (a, b)
}

enum MyOption<T> {
    Some(T),
    None,
}

enum MyResult<T, E> {
    Ok(T),
    Err(E),
}

fn print_all<T: Display>(items: &[T]) { }

fn notify<T>(item: &T)
where
    T: Summary + Display,
{ }

struct ConstArray<T, const N: usize> {
    items: [T; N],
}

fn sum_array<const N: usize>(arr: [i32; N]) -> i32 {
    arr.iter().sum()
}

fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
    move |y| x + y
}

=== 1. 泛型函数 ===
largest(&numbers) = 100
largest(&chars) = y
largest(&floats) = 3.2
largest_ref(&numbers) = 100

=== 2. 泛型结构体 ===
integer = Point { x: 5, y: 10 }
float = Point { x: 1.0, y: 4.0 }

trait Summary {
    fn summarize_author(&self) -> String;

    fn summarize(&self) -> String {
        format!("(阅读更多来自 {} 的内容...)", self.summarize_author())
    }
}

struct Tweet {
    username: String,
    content: String,
}

impl Summary for Tweet {
    fn summarize_author(&self) -> String {
        format!("@{}", self.username)
    }

    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}