Rust 闭包类型 Fn、FnMut 和 FnOnce

Rust 通过闭包提供了一种灵活的方式来处理函数式编程的概念。Rust 中有三种主要的闭包类型：Fn、FnMut 和 FnOnce。每种类型都有其特定的用途和行为。

• 定义：Fn 是一种闭包类型，表示可以被多次调用且不会修改捕获的环境。
• 特点：
  • 可以被多次调用。
  • 不会修改捕获的变量。
  • 通常用于只读操作。

let add = |x: i32, y: i32| -> i32 { x + y };
let result1 = add(5, 10); // result1 = 15
let result2 = add(3, 7);  // result2 = 10

• 定义：FnMut 是一种闭包类型，表示可以被多次调用且可以修改捕获的环境。
• 特点：
  • 可以被多次调用。
  • 可以修改捕获的变量。
  • 通常用于需要修改状态的操作。

let mut count = 0;
let mut increment = || {
    count += 1;
    println!("Count: {}", count);
};
increment(); // Count: 1
increment(); // Count: 2

• 定义：FnOnce 是一种闭包类型，表示可以被调用一次且可能消耗捕获的环境。
• 特点：
  • 可以被调用一次。
  • 可能消耗捕获的变量。
  • 通常用于需要消耗资源的操作。

let name = String::from("Alice");
let greet = move || println!("Hello, {}", name);
greet(); // Hello, Alice
// greet(); // Error: use of moved value: `greet`

闭包类型的使用场景

• 适用场景：
  • 需要多次调用且不修改捕获环境的函数。
  • 用于只读操作，如计算、查询等。
• 示例：

fn apply_twice<F>(f: F, x: i32) -> i32
where
    F: Fn(i32) -> i32,
{
    f(f(x))
}

let double = |x| x * 2;
let result = apply_twice(double, 5); // result = 20

• 适用场景：
  • 需要多次调用且可能修改捕获环境的函数。
  • 用于需要修改状态的操作，如计数器、累加器等。
• 示例：

fn apply_n_times<F>(mut f: F, x: i32, n: i32)
where
    F: FnMut(i32) -> i32,
{
    let mut result = x;
    for _ in 0..n {
        result = f(result);
    }
    println!("Result: {}", result);
}

let mut count = 0;
let mut increment = |x| {
    count += 1;
    x + 1
};
apply_n_times(increment, 0, 5); // Result: 5

• 适用场景：
  • 需要调用一次且可能消耗捕获环境的函数。
  • 用于需要消耗资源的操作，如文件读写、网络请求等。
• 示例：

fn consume<F>(f: F)
where
    F: FnOnce(),
{
    f();
}

let name = String::from("Bob");
let greet = move || println!("Hello, {}", name);
consume(greet); // Hello, Bob
// consume(greet); // Error: use of moved value: `greet`