1

let add_one = |x: i32| -> i32 { x + 1 };  // 一个简单的闭包，给数字加1

1

let closure_name = |parameters| -> return_type { body };

1

let closure_name = |parameters| { body };

1

let closure_name = |parameters| expression;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

fn main() {
    // 带完整类型标注的闭包
    let square = |x: i32| -> i32 { x * x };  // 计算平方
    println!("5 的平方是: {}", square(5));  // 25

    // 省略返回类型，编译器会自动推断
    let double = |x: i32| { x * 2 };  // 计算两倍
    println!("7 的两倍是: {}", double(7));  // 14

    // 单行表达式可以省略大括号
    let is_even = |x: i32| x % 2 == 0;  // 判断是否为偶数
    println!("8 是偶数吗? {}", is_even(8));  // true

    // 没有参数的闭包
    let answer = || { 42 };  // 直接返回一个值
    println!("生命的意义是: {}", answer());  // 42
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

fn main() {
    // 单参数闭包：判断一个数是否大于10
    let greater_than_ten = |x: i32| -> bool { x > 10 };
    println!("15 > 10 吗? {}", greater_than_ten(15));  // true

    // 多参数闭包：计算两个数的和与积
    let add_and_multiply = |a: i32, b: i32| -> (i32, i32) {
        (a + b, a * b)
    };
    let (sum, product) = add_and_multiply(3, 4);
    println!("3 + 4 = {}, 3 * 4 = {}", sum, product);  // 7, 12

    // 无参数闭包：返回一个固定值
    let get_max_i32 = || -> i32 { i32::MAX };
    println!("i32 的最大值是: {}", get_max_i32());  // 2147483647

    // 无参数闭包：访问外部变量
    let base = 100;
    let add_to_base = || -> i32 { base + 50 };
    println!("100 + 50 = {}", add_to_base());  // 150
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

fn main() {
    // 闭包赋值给变量
    let greet = |name: &str| {
        format!("你好, {}! 欢迎来到 Rust 的世界!", name)
    };
    println!("{}", greet("小明"));  // 你好, 小明! 欢迎来到 Rust 的世界!

    // 闭包存储在 Vector 中（但需要使用 Box 包装）
    let mut calculators: Vec<Box<dyn Fn(i32) -> i32>> = Vec::new();
    calculators.push(Box::new(|x| x * 2));  // 两倍
    calculators.push(Box::new(|x| x * x));  // 平方
    calculators.push(Box::new(|x| x - 1));  // 减一

    // 使用下标调用不同的闭包
    println!("8 的两倍是: {}", calculators[0](8));  // 16
    println!("8 的平方是: {}", calculators[1](8));  // 64
    println!("8 减 1 是: {}", calculators[2](8));  // 7

    // 将闭包作为函数参数传递（稍后会详细讲解）
    let numbers = vec![1, 2, 3, 4, 5];
    let result = apply_with_op(&numbers, |x| x * 2);
    println!("每个数翻倍: {:?}", result);  // [2, 4, 6, 8, 10]
}

// 一个接受闭包作为参数的函数
fn apply_with_op(nums: &[i32], op: impl Fn(i32) -> i32) -> Vec<i32> {
    nums.iter().map(|&x| op(x)).collect()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

fn main() {
    // 多行闭包：复杂的数学计算
    let complex_calc = |x: f64| -> f64 {
        let part1 = x.powi(2);  // x 的平方
        let part2 = (x * std::f64::consts::PI).sin();  // x * π 的正弦
        let part3 = x.sqrt();  // x 的平方根
        (part1 + part2) / part3  // 返回组合结果
    };

    println!("当 x=4.0 时的复杂计算结果: {:.4}", complex_calc(4.0));

    // 多行闭包：字符串处理
    let process_text = |text: &str| -> String {
        let trimmed = text.trim();  // 去除首尾空白
        let uppercased = trimmed.to_uppercase();  // 转大写
        let words: Vec<&str> = uppercased.split_whitespace().collect();  // 分词
        words.join("_")  // 用下划线连接
    };

    let input = "  Hello Rust World  ";
    println!("处理后的文本: {}", process_text(input));  // HELLO_RUST_WORLD

    // 多行闭包：模拟一个简单的状态机
    let tick_tock = |state: &mut bool| -> &str {
        *state = !*state;  // 切换状态
        if *state {
            "Tick"
        } else {
            "Tock"
        }
    };

    let mut is_tick = true;
    println!("{}", tick_tock(&mut is_tick));  // Tick
    println!("{}", tick_tock(&mut is_tick));  // Tock
    println!("{}", tick_tock(&mut is_tick));  // Tick
    println!("{}", tick_tock(&mut is_tick));  // Tock
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

fn main() {
    // 闭包 add_a 和 add_b 看起来完全一样，但它们是不同的类型！
    let add_a = |x: i32| x + 5;
    let add_b = |x: i32| x + 5;

    // 即使类型签名相同，下面的代码也无法编译：
    // let another_add = add_a;  // 错误：不能这样赋值
    // 原因：闭包的类型是私有的，编译器自动生成的，没人知道它叫啥

    // 正确的方式：使用泛型或者 dyn trait
    let mut closures: Vec<Box<dyn Fn(i32) -> i32>> = Vec::new();
    closures.push(Box::new(add_a));  // 包装成 dyn Fn
    // closures.push(Box::new(add_b));  // 同样可以添加另一个闭包

    println!("使用闭包 add_a: {}", closures[0](10));  // 15

    // 如果你想让多个闭包有相同的类型以便存储在一起，必须使用 trait 对象
    fn use_closure<F>(f: F) where F: Fn(i32) -> i32 {
        println!("结果是: {}", f(100));
    }

    let my_closure = |x| x * 2;
    use_closure(my_closure);  // 200
    use_closure(|x| x + 1);  // 101，直接使用内联闭包
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

fn main() {
    let value = 10;

    // 这个闭包捕获的是 value 的不可变引用
    let read_value = || println!("value 是: {}", value);

    // 这个闭包... 等等，如果你想修改 value，你需要用 mut
    let mut value = 10;  // 注意：这里是可变的 value
    let read_and_increment = || {
        value += 1;
        println!("value 变成了: {}", value);
    };

    read_value();  // value 是: 10
    read_and_increment();  // value 变成了: 11
    read_and_increment();  // value 变成了: 12

    // 每次调用 read_and_increment，value 都会变化
    // 因为这个闭包捕获的是 value 的可变引用
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

fn main() {
    let greeting = "你好".to_string();

    // 这个闭包实现了 Fn trait，因为它只是"借用"了 greeting
    let say_hello = || {
        println!("{}, 世界!", greeting);  // greeting 被借用，不是被移动
    };

    // 可以调用任意多次
    say_hello();  // 你好, 世界!
    say_hello();  // 你好, 世界!
    say_hello();  // 你好, 世界!

    // greeting 仍然有效！
    println!("闭包调用完毕后，greeting 还在: {}", greeting);  // 你好

    // Fn 闭包可以作为函数参数
    fn call_twice<F: Fn()>(f: F) {
        f();
        f();
    }

    call_twice(say_hello);
    // 你好, 世界!
    // 你好, 世界!
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

fn main() {
    let mut counter = 0;

    // 这个闭包实现了 FnMut trait，因为它修改了 counter
    let mut increment = || {
        counter += 1;
        println!("计数器的当前值: {}", counter);
    };

    // 第一次调用
    increment();  // 计数器的当前值: 1

    // 第二次调用
    increment();  // 计数器的当前值: 2

    // 第三次调用
    increment();  // 计数器的当前值: 3

    // FnMut 闭包可以作为可变借用的参数
    fn call_mutually<F: FnMut()>(mut f: F) {
        f();
        f();
    }

    let mut base = 10;
    call_mutually(|| {
        base *= 2;
        println!("base 翻倍了: {}", base);
    });
    // base 翻倍了: 20
    // base 翻倍了: 40
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

fn main() {
    let words = vec!["Rust", "是", "很", "酷", "的"];

    // 这个闭包实现了 FnOnce trait，因为它"吃掉"了 words
    let consume_and_print = || {
        // words 被移动进这个闭包了
        let copied_words = words;  // 所有权转移
        println!("被吃掉的 words: {:?}", copied_words);
    };

    // 只能调用一次！
    consume_and_print();

    // 下面的代码无法编译，因为 words 已经被"吃掉"了：
    // consume_and_print();  // 错误：words 已经被移动
    // println!("{:?}", words);  // 错误：words 不再属于这里

    // FnOnce 经常与 move 一起使用
    let data = vec![1, 2, 3];
    let move_closure = move || {
        println!("data 被打包带走了: {:?}", data);
        // data 被移动进闭包，此后再也无法在外部访问
    };

    move_closure();
    // move_closure();  // 错误：只能调用一次

    // 有趣的是，FnOnce 闭包可以用闭包表达式（|| expr）直接调用一次
    (|| {
        let msg = String::from("一次性闭包");
        println!("{}", msg);
    })();
}

1
2
3
4
5

FnOnce
  ↑
FnMut
  ↑
Fn

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

fn main() {
    // 演示 trait 约束的使用
    fn call_fn<F: Fn()>(f: F) { f(); }           // 最严格，只能是 Fn
    fn call_fn_mut<F: FnMut()>(mut f: F) { f(); }  // 中等，可以是 Fn 或 FnMut
    fn call_fn_once<F: FnOnce()>(f: F) { f(); }     // 最宽松，都行

    let value = "Hello".to_string();

    // 这个闭包是 Fn，因为它只是借用了 value
    let read_only = || println!("读取: {}", value);

    // Fn 可以传递给任何接受 Fn/FnMut/FnOnce 的函数
    call_fn(read_only);       // OK: Fn -> Fn
    call_fn_mut(read_only);   // OK: Fn -> FnMut
    call_fn_once(read_only);  // OK: Fn -> FnOnce

    println!("\n--- 分割线 ---\n");

    // 演示 FnMut 的例子
    let mut count = 0;
    let mut increment = || { count += 1; };

    // FnMut 不能传递给只接受 Fn 的函数
    // call_fn(increment);  // 错误：FnMut 不能传给 Fn
    call_fn_mut(increment);   // OK: FnMut -> FnMut
    call_fn_once(increment);  // OK: FnMut -> FnOnce

    println!("\n--- 分割线 ---\n");

    // 演示 FnOnce 的例子
    let owned = vec![1, 2, 3];
    let consume = move || { owned };  // FnOnce，捕获的值会被移动

    // FnOnce 只能传给 FnOnce
    // call_fn(consume);     // 错误
    // call_fn_mut(consume); // 错误
    call_fn_once(consume);    // OK: FnOnce -> FnOnce

    println!("\n三者的关系总结:");
    println!("Fn: 可以多次调用，只借用环境");
    println!("FnMut: 可以多次调用，借用并修改环境");
    println!("FnOnce: 只调用一次，会消费环境中的值");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

┌─────────────────────────────────────────────────────────┐
│                    FnOnce (最宽泛)                      │
│  "我只调用一次，但我不挑食，什么闭包都行"                  │
└───────────────────────┬─────────────────────────────────┘
                        │ 继承
┌───────────────────────▼─────────────────────────────────┐
│                    FnMut (中等)                          │
│  "我可以调用多次，但我可能会改变闭包的状态"                │
└───────────────────────┬─────────────────────────────────┘
                        │ 继承
┌───────────────────────▼─────────────────────────────────┐
│                      Fn (最严格)                         │
│  "我最守规矩，只读取不修改，可以随便调用"                   │
└─────────────────────────────────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

fn main() {
    let message = String::from("Rust 编程");

    // 按引用捕获，不会获得 message 的所有权
    let print_ref = || {
        println!("闭包中的 message (引用): {}", message);
    };

    print_ref();
    print_ref();
    print_ref();  // 想调用多少次都行

    // message 仍然有效，可以继续使用
    println!("闭包外部的 message: {}", message);  // Rust 编程

    // 另一个按引用捕获的例子
    let numbers = vec![1, 2, 3, 4, 5];
    let sum = || {
        numbers.iter().sum::<i32>()
    };

    println!("数字之和: {}", sum());  // 15
    println!("原始数组还在: {:?}", numbers);  // [1, 2, 3, 4, 5]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

fn main() {
    let mut score = 0;

    // 按可变引用捕获，闭包需要修改 score
    let mut increment = || {
        score += 1;
        println!("分数增加了，当前分数: {}", score);
    };

    increment();  // 分数增加了，当前分数: 1
    increment();  // 分数增加了，当前分数: 2
    increment();  // 分数增加了，当前分数: 3

    // score 被修改了
    println!("最终分数: {}", score);  // 3

    // 另一个例子：闭包内部维护状态
    let mut state = String::from("初始状态");

    let mut modify_state = || {
        state.push_str(" -> 被修改");
        println!("状态更新: {}", state);
    };

    modify_state();
    // 外部的 state 也被修改了
    println!("外部观察: {}", state);  // 初始状态 -> 被修改

    // 注意：按可变引用捕获的闭包，在调用时不能有其他借用存在
    let text = String::from("Hello");

    let mut to_uppercase = || {
        // text.push_str(" World");  // 错误：text 被可变借用，但这是 FnMut
        println!("转换为大写: {}", text.to_uppercase());
    };

    to_uppercase();
    // text.to_uppercase() 创建了一个新的 String，没有修改 original
    println!("原始文本: {}", text);  // Hello
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

fn main() {
    let name = String::from("Rust");

    // 按值捕获，name 的所有权被移动进闭包
    let capture_by_value = move || {
        println!("闭包拥有 name: {}", name);
        // name 在这里被使用后就不再属于外部作用域了
    };

    capture_by_value();
    // capture_by_value();  // 错误：FnOnce 闭包只能调用一次

    // 下面的代码无法编译，因为 name 已经被移走了
    // println!("{}", name);  // 错误：name 被移动

    println!("\n--- 分割线 ---\n");

    // 常见场景：在多线程中使用闭包
    use std::thread;

    let data = vec![1, 2, 3, 4, 5];

    // 在新线程中使用闭包，必须 move，因为线程可能会在主线程结束前执行
    let handle = thread::spawn(move || {
        println!("子线程读取 data: {:?}", data);
        // data 在这里是独立的所有权
        let sum: i32 = data.iter().sum();
        sum
    });

    let result = handle.join().unwrap();
    println!("子线程计算结果: {}", result);  // 15

    // data 已经在主线程中无效了
    // println!("{:?}", data);  // 错误：data 已被移动

    println!("\n--- 分割线 ---\n");

    // 数值类型按值捕获仍然可以多次使用
    let number = 42;

    let print_number = move || {
        println!("捕获的数字: {}", number);
        println!("再捕获一次: {}", number);
    };

    print_number();  // 42, 42
    // print_number();  // 错误：虽然 i32 是 Copy，但 move 闭包是 FnOnce
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

fn main() {
    // 规则1：不可变借用
    let text = String::from("Hello");
    let print = || println!("{}", text);  // &String
    print();
    println!("外部还能用: {}", text);  // Hello

    // 规则2：可变借用
    let mut counter = 0;
    let mut inc = || { counter += 1; };  // &mut counter
    inc();
    println!("计数器: {}", counter);  // 1

    // 规则3：消费变量（FnOnce）
    let owned = vec![1, 2, 3];
    let consume = || { owned };  // 消费 owned，owned 被移动
    let taken = consume();
    println!("取走的内容: {:?}", taken);  // [1, 2, 3]
    // println!("{:?}", owned);  // 错误：owned 已被移走

    // 规则4：Copy 类型总是值捕获
    let x = 5;
    let use_x = || println!("x = {}", x);  // 值捕获，因为 i32 是 Copy
    use_x();
    println!("x 还在: {}", x);  // x 还在，因为是副本
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

fn main() {
    // 使用泛型 + trait bound 接受闭包参数
    fn apply<F>(x: i32, f: F) -> i32
    where
        F: Fn(i32) -> i32,  // F 是一个接收 i32 返回 i32 的闭包
    {
        f(x)
    }

    // 使用具体的闭包
    let square = |x: i32| x * x;
    let triple = |x: i32| x * 3;
    let negate = |x: i32| -x;

    println!("平方: apply(5, square) = {}", apply(5, square));  // 25
    println!("三倍: apply(5, triple) = {}", apply(5, triple));  // 15
    println!("取反: apply(5, negate) = {}", apply(5, negate));  // -5

    // 直接传入内联闭包
    println!("加10: apply(7, |x| x + 10) = {}", apply(7, |x| x + 10));  // 17

    // 组合多个操作
    fn compose<A, B, C, F, G>(f: F, g: G) -> impl Fn(A) -> C
    where
        F: Fn(A) -> B,
        G: Fn(B) -> C,
    {
        move |x| g(f(x))
    }

    let add_one = |x: i32| x + 1;
    let double = |x: i32| x * 2;
    let add_one_then_double = compose(add_one, double);

    println!("(5 + 1) * 2 = {}", add_one_then_double(5));  // 12

    // 接受多个闭包参数
    fn apply_both<F, G>(x: i32, y: i32, f: F, g: G) -> i32
    where
        F: Fn(i32, i32) -> i32,
        G: Fn(i32) -> i32,
    {
        g(f(x, y))
    }

    let add = |a, b| a + b;
    println!("(3 + 4) * 10 = {}", apply_both(3, 4, add, |x| x * 10));  // 70
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

// 策略模式的例子
fn main() {
    // 定义一个排序策略
    trait SortStrategy<T> {
        fn sort(&self, data: &mut [T])
        where
            T: Ord;
    }

    // 升序策略
    struct Ascending;
    impl<T: Ord> SortStrategy<T> for Ascending {
        fn sort(&self, data: &mut [T]) {
            data.sort();
        }
    }

    // 降序策略
    struct Descending;
    impl<T: Ord> SortStrategy<T> for Descending {
        fn sort(&self, data: &mut [T]) {
            data.sort_by(|a, b| b.cmp(a));
        }
    }

    // 使用闭包作为策略
    fn sort_with<F>(data: &mut [i32], compare: F)
    where
        F: Fn(&i32, &i32) -> std::cmp::Ordering,
    {
        data.sort_by(compare);
    }

    let mut numbers = vec![3, 1, 4, 1, 5, 9, 2, 6];

    // 使用闭包实现奇数优先排序
    sort_with(&mut numbers, |a, b| {
        let a_is_odd = a % 2 == 1;
        let b_is_odd = b % 2 == 1;
        if a_is_odd != b_is_odd {
            if a_is_odd { std::cmp::Ordering::Less } else { std::cmp::Ordering::Greater }
        } else {
            a.cmp(b)
        }
    });

    println!("奇数优先排序: {:?}", numbers);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

fn main() {
    // 使用 impl Trait 语法返回闭包
    fn make_adder(n: i32) -> impl Fn(i32) -> i32 {
        move |x| x + n  // 返回一个捕获了 n 的闭包
    }

    let add_5 = make_adder(5);
    let add_10 = make_adder(10);
    let add_100 = make_adder(100);

    println!("5 + 5 = {}", add_5(5));   // 10
    println!("5 + 10 = {}", add_10(5));  // 15
    println!("5 + 100 = {}", add_100(5)); // 105

    // make_adder 是闭包工厂函数的经典例子
    // 每次调用都会创建一个新的闭包实例
    println!("\n--- 分割线 ---\n");

    // 返回可变的闭包
    fn make_counter(start: i32) -> impl FnMut() -> i32 {
        let mut current = start;
        move || {
            current += 1;
            current
        }
    }

    let mut counter1 = make_counter(0);
    let mut counter2 = make_counter(100);

    println!("计数器1: {}", counter1());  // 1
    println!("计数器1: {}", counter1());  // 2
    println!("计数器1: {}", counter1());  // 3
    println!("计数器2: {}", counter2());  // 101
    println!("计数器2: {}", counter2());  // 102

    println!("\n--- 分割线 ---\n");

    // 返回一次性闭包 (FnOnce)
    fn create_greeter(name: String) -> impl FnOnce() {
        move || {
            println!("你好, {}!", name);
        }
    }

    let greeter = create_greeter(String::from("Rustacean"));
    greeter();  // 你好, Rustacean!

    // 更复杂的例子：返回一个数学函数
    fn make_multiplier(factor: f64) -> impl Fn(f64) -> f64 {
        move |x| x * factor
    }

    let triple = make_multiplier(3.0);
    let root = make_multiplier(0.5);

    println!("5 * 3 = {}", triple(5.0));   // 15
    println!("5 * 0.5 = {}", root(5.0));    // 2.5
    println!("sqrt(16) = {}", triple(root(16.0)));  // 24
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

fn main() {
    // 使用 Box<dyn Fn> 可以返回不同类型的闭包
    fn create_calculator(op: &str) -> Box<dyn Fn(i32, i32) -> i32> {
        match op {
            "add" => Box::new(|a, b| a + b),
            "sub" => Box::new(|a, b| a - b),
            "mul" => Box::new(|a, b| a * b),
            "div" => Box::new(|a, b| a / b),
            _ => Box::new(|_, _| 0),
        }
    }

    let calculator = create_calculator("add");
    println!("10 + 5 = {}", calculator(10, 5));  // 15

    let calculator = create_calculator("mul");
    println!("10 * 5 = {}", calculator(10, 5));  // 50
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

fn main() {
    // 基本用法：move 强制闭包获取变量的所有权
    let data = vec![1, 2, 3];

    // 没有 move：闭包借用 data
    let borrow_only = || println!("借用: {:?}", data);
    println!("调用前: {:?}", data);  // data 还在
    borrow_only();
    println!("调用后: {:?}", data);  // data 还在

    println!("\n--- 分割线 ---\n");

    // 有 move：闭包获取 data 的所有权
    let data2 = vec![4, 5, 6];
    let take_ownership = move || println!("所有权转移: {:?}", data2);
    take_ownership();
    // 下面的代码无法编译，因为 data2 已经被移走了
    // println!("{:?}", data2);  // 错误！

    println!("\n--- 分割线 ---\n");

    // move 在多线程中的重要性
    use std::thread;

    let shared_data = vec![1, 2, 3];

    // 在 spawn 中使用 move 确保数据在线程间安全传递
    let handle = thread::spawn(move || {
        println!("子线程读取: {:?}", shared_data);
        // shared_data 在这里是独立的所有权
    });

    handle.join().unwrap();

    // 主线程中 shared_data 已经无效
    // println!("{:?}", shared_data);  // 错误！

    println!("\n--- 分割线 ---\n");

    // move 闭包与 FnOnce 的关系
    fn call_once<F: FnOnce()>(f: F) {
        f();
    }

    let important_data = String::from("重要的数据");

    // 这里必须用 move，因为闭包是 FnOnce
    call_once(move || {
        println!("{}", important_data);
    });

    // 重要数据已经被"消费"了
    // println!("{}", important_data);  // 错误！

    println!("\n--- 分割线 ---\n");

    // move 与闭包捕获的组合
    let x = 10;
    let y = 20;

    // 同时使用 move 和其他捕获方式
    let closure_with_move = move || {
        // x 被移动进来了（i32 是 Copy，所以外部的 x 仍然有效）
        let copied_x = x;  // 复制了一份
        copied_x + y  // y 是借用的
    };

    println!("闭包结果: {}", closure_with_move());  // 30
    println!("x 还在: {}", x);  // 10，i32 是 Copy
    // println!("y 还在: {}", y);  // 错误：y 被借用了
}

1
2
3
4
5
6
7
8

pub trait Iterator {
    type Item;  // 迭代器产生的元素类型

    // 核心方法：返回下一个元素
    fn next(&mut self) -> Option<Self::Item>;

    // 其他默认方法...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

fn main() {
    // 看看 Iterator trait 的基本结构
    let numbers = vec![1, 2, 3];

    // iter() 返回一个迭代器
    let mut iter = numbers.iter();

    // 手动调用 next 方法
    println!("第一个元素: {:?}", iter.next());  // Some(&1)
    println!("第二个元素: {:?}", iter.next());  // Some(&2)
    println!("第三个元素: {:?}", iter.next());  // Some(&3)
    println!("没有更多元素: {:?}", iter.next());  // None

    println!("\n--- 分割线 ---\n");

    // for 循环背后的秘密
    let fruits = vec!["苹果", "香蕉", "橙子"];

    println!("使用 for 循环遍历:");
    for fruit in &fruits {
        println!("  水果: {}", fruit);
    }

    // 等价于手动调用迭代器
    println!("\n手动调用 next():");
    let mut fruit_iter = fruits.iter();
    while let Some(fruit) = fruit_iter.next() {
        println!("  水果: {}", fruit);
    }

    println!("\n--- 分割线 ---\n");

    // 创建自定义迭代器
    struct Counter {
        count: u32,
    }

    impl Counter {
        fn new() -> Counter {
            Counter { count: 0 }
        }
    }

    impl Iterator for Counter {
        type Item = u32;

        fn next(&mut self) -> Option<Self::Item> {
            if self.count < 5 {
                self.count += 1;
                Some(self.count)
            } else {
                None
            }
        }
    }

    let counter = Counter::new();
    for num in counter {
        println!("计数器: {}", num);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

┌─────────────────────────────────────────────────────────┐
│                    Iterator Trait                       │
├─────────────────────────────────────────────────────────┤
│  type Item;        // 迭代器产生的元素类型               │
├─────────────────────────────────────────────────────────┤
│  fn next(&mut self) -> Option<Self::Item>               │
│                                                         │
│  返回值:                                                 │
│    Some(item) -> 还有元素，返回当前元素                  │
│    None      -> 迭代结束，没有更多元素                   │
└─────────────────────────────────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

fn main() {
    let data = vec![1, 2, 3, 4, 5];

    // iter(): 创建不可变引用的迭代器
    // 元素类型: &i32
    println!("=== iter() - 不可变引用 ===");
    for num in data.iter() {
        println!("  数值: {} (不可修改)", num);
    }
    // data 仍然完全拥有所有权
    println!("原始 vec 还在: {:?}", data);

    println!("\n--- 分割线 ---\n");

    // iter_mut(): 创建可变引用的迭代器
    // 元素类型: &mut i32
    let mut mutable_data = vec![1, 2, 3, 4, 5];
    println!("=== iter_mut() - 可变引用 ===");

    for num in mutable_data.iter_mut() {
        *num *= 2;  // 修改每个元素
        println!("  修改后的值: {}", num);
    }
    // data 被修改了
    println!("修改后的 vec: {:?}", mutable_data);

    println!("\n--- 分割线 ---\n");

    // into_iter(): 获取所有权的迭代器
    // 元素类型: i32 (所有权被移走)
    let owned_data = vec![10, 20, 30];
    println!("=== into_iter() - 获取所有权 ===");

    for num in owned_data.into_iter() {
        println!("  获取的值: {} (拥有所有权)", num);
    }
    // data 的所有权已经被移走，无法再使用
    // println!("{:?}", owned_data);  // 错误！

    println!("\n--- 分割线 ---\n");

    // 在 for 循环中直接使用这些方法
    let numbers = vec![1, 2, 3];

    // for item in numbers.iter()  等价于  for item in &numbers
    println!("使用 &numbers:");
    for n in &numbers {
        println!("  {}", n);
    }

    // for item in numbers.iter_mut()  等价于  for item in &mut numbers
    let mut nums = vec![1, 2, 3];
    println!("使用 &mut nums:");
    for n in &mut nums {
        *n += 10;
    }
    println!("  修改后: {:?}", nums);

    // for item in numbers.into_iter()  等价于  for item in numbers
    println!("使用 into_iter:");
    let nums2 = vec![1, 2, 3];
    for n in nums2 {
        println!("  {}", n);
    }
    // nums2 已经被移动
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

┌─────────────────────────────────────────────────────────┐
│              迭代器创建方式对比                          │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  data.iter()       ->  Iterator<Item = &i32>           │
│                      只读借用                           │
│                      data 仍然有效                      │
│                                                         │
│  data.iter_mut()   ->  Iterator<Item = &mut i32>       │
│                      可变借用                           │
│                      data 可以被修改                    │
│                                                         │
│  data.into_iter()  ->  Iterator<Item = i32>            │
│                      获取所有权                         │
│                      data 不再有效                      │
│                                                         │
└─────────────────────────────────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

fn main() {
    // 基础 range: start..end (不包含 end)
    println!("=== start..end (不包含 end) ===");
    for i in 0..5 {
        print!("{} ", i);  // 0 1 2 3 4
    }
    println!();

    // 包含 end 的 range: start..=end
    println!("\n=== start..=end (包含 end) ===");
    for i in 0..=5 {
        print!("{} ", i);  // 0 1 2 3 4 5
    }
    println!();

    // 字符 range
    println!("\n=== 字符 range ===");
    for c in 'a'..='e' {
        print!("{} ", c);  // a b c d e
    }
    println!();

    // 使用 range 创建迭代器
    println!("\n=== range 迭代器的各种方法 ===");

    // collect: 收集到 Vec
    let squares: Vec<i32> = (1..=5).map(|x| x * x).collect();
    println!("1-5 的平方: {:?}", squares);  // [1, 4, 9, 16, 25]

    // sum: 求和
    let total: i32 = (1..=100).sum();
    println!("1-100 的和: {}", total);  // 5050

    // product: 求积
    let product: i32 = (1..=5).product();
    println!("1-5 的积: {}", product);  // 120

    // reverse: 反向
    let reversed: Vec<i32> = (1..=5).rev().collect();
    println!("反向: {:?}", reversed);  // [5, 4, 3, 2, 1]

    // step_by: 跳过指定步长
    let evens: Vec<i32> = (0..=10).step_by(2).collect();
    println!("偶数: {:?}", evens);  // [0, 2, 4, 6, 8, 10]

    // float range (需要使用特定方法)
    println!("\n=== Float Range ===");
    use std::iter::successors;

    // 模拟浮点数 range
    let float_range: Vec<f64> = successors(Some(0.0), |&x| {
        Some((x + 0.5).min(2.5))
    }).collect();

    println!("浮点数序列: {:?}", float_range);
    // [0.0, 0.5, 1.0, 1.5, 2.0, 2.5]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

fn main() {
    // 基本的 map 用法
    let numbers = vec![1, 2, 3, 4, 5];

    // 将每个数平方
    let squares: Vec<i32> = numbers.iter().map(|x| x * x).collect();
    println!("平方: {:?}", squares);  // [1, 4, 9, 16, 25]

    // 将字符串转换为大写
    let words = vec!["hello", "rust", "world"];
    let uppercased: Vec<String> = words.iter().map(|s| s.to_uppercase()).collect();
    println!("大写: {:?}", uppercased);  // ["HELLO", "RUST", "WORLD"]

    // map 可以链式调用
    let result: Vec<i32> = (1..=5)
        .map(|x| x * 2)     // 先翻倍: [2, 4, 6, 8, 10]
        .map(|x| x + 10)    // 再加10: [12, 14, 16, 18, 20]
        .map(|x| x % 7)     // 取模7
        .collect();
    println!("链式 map: {:?}", result);  // [5, 0, 2, 4, 6]

    println!("\n--- 分割线 ---\n");

    // map 与闭包组合
    #[derive(Debug)]
    struct Person {
        name: String,
        age: u32,
    }

    let people = vec![
        Person { name: String::from("Alice"), age: 30 },
        Person { name: String::from("Bob"), age: 25 },
        Person { name: String::from("Charlie"), age: 35 },
    ];

    // 提取所有人的名字
    let names: Vec<&str> = people.iter().map(|p| p.name.as_str()).collect();
    println!("所有人的名字: {:?}", names);  // ["Alice", "Bob", "Charlie"]

    // 计算每个人的年龄段
    let age_groups: Vec<&str> = people.iter().map(|p| {
        match p.age {
            0..=17 => "未成年",
            18..=35 => "青年",
            36..=60 => "中年",
            _ => "老年",
        }
    }).collect();
    println!("年龄段: {:?}", age_groups);  // ["青年", "青年", "中年"]

    println!("\n--- 分割线 ---\n");

    // map 不会立即执行（惰性求值）
    let numbers = vec![1, 2, 3];
    let lazy_map = numbers.iter().map(|x| {
        println!("处理: {}", x);  // 这行不会立即执行
        x * 2
    });

    println!("迭代器已创建，但还没有处理任何元素");

    // 只有当消费迭代器时，map 才会真正执行
    println!("开始消费:");
    let result: Vec<i32> = lazy_map.collect();
    println!("结果: {:?}", result);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

fn main() {
    // 基本的 filter 用法
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    // 过滤出偶数
    let evens: Vec<&i32> = numbers.iter().filter(|x| *x % 2 == 0).collect();
    println!("偶数: {:?}", evens);  // [2, 4, 6, 8, 10]

    // 过滤出大于5的数
    let greater_than_five: Vec<&i32> = numbers.iter().filter(|x| **x > 5).collect();
    println!("大于5的数: {:?}", greater_than_five);  // [6, 7, 8, 9, 10]

    println!("\n--- 分割线 ---\n");

    // map 和 filter 组合
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    // 找出偶数，然后平方
    let result: Vec<i32> = numbers
        .iter()
        .filter(|x| *x % 2 == 0)  // 先过滤
        .map(|x| x * x)           // 再映射
        .collect();
    println!("偶数的平方: {:?}", result);  // [4, 16, 36, 64, 100]

    // 过滤字符串
    let words = vec!["apple", "banana", "cherry", "date", "elderberry"];

    // 过滤长度大于5的单词，并转换为大写
    let long_words: Vec<String> = words
        .iter()
        .filter(|w| w.len() > 5)
        .map(|w| w.to_uppercase())
        .collect();
    println!("长单词(大写): {:?}", long_words);  // ["BANANA", "CHERRY", "ELDERBERRY"]

    println!("\n--- 分割线 ---\n");

    // filter 使用更复杂的条件
    #[derive(Debug)]
    struct Product {
        name: String,
        price: f64,
        in_stock: bool,
    }

    let products = vec![
        Product { name: String::from("笔记本"), price: 59.99, in_stock: true },
        Product { name: String::from("手机"), price: 999.99, in_stock: false },
        Product { name: String::from("耳机"), price: 149.99, in_stock: true },
        Product { name: String::from("充电器"), price: 29.99, in_stock: true },
        Product { name: String::from("平板电脑"), price: 399.99, in_stock: false },
    ];

    // 过滤：在库存中且价格小于100的
    let affordable_in_stock: Vec<&Product> = products
        .iter()
        .filter(|p| p.in_stock && p.price < 100.0)
        .collect();

    println!("便宜且有货的产品:");
    for product in &affordable_in_stock {
        println!("  {} - ¥{:.2}", product.name, product.price);
    }
    // 笔记本 - ¥59.99
    // 耳机 - ¥149.99 (这个不会出现在结果中，因为 > 100)
    // 充电器 - ¥29.99

    println!("\n--- 分割线 ---\n");

    // filter_map: 同时过滤和转换
    let strings = vec!["1", "two", "3", "four", "5"];

    // filter_map 会过滤掉 None，只保留 Some
    let numbers: Vec<i32> = strings
        .iter()
        .filter_map(|s| s.parse::<i32>().ok())
        .collect();
    println!("解析出的数字: {:?}", numbers);  // [1, 3, 5]

    // 等价的 map + filter
    let numbers2: Vec<i32> = strings
        .iter()
        .map(|s| s.parse::<i32>().ok())
        .filter(|opt| opt.is_some())
        .map(|opt| opt.unwrap())
        .collect();
    println!("用 map+filter 实现: {:?}", numbers2);  // [1, 3, 5]
}