迭代器与闭包

它在解决什么

这两样东西在 Rust 里是绑在一起的：迭代器的每个适配器都吃一个闭包， 而闭包最常见的用处就是喂给迭代器。

从 JS / Java Stream / Python 过来的人对 map / filter 不陌生， 所以这一篇同样只讲不一样的地方：惰性的可见后果、 三个 Fn trait 的区别、以及 move 什么时候是必需的。

🚨 惰性：不消费就什么都不会发生

这是最容易踩的一条，因为在别的语言里未必如此。

看这条示例的输出顺序：

还没开始        ← 先印的是这句
处理 1
处理 2
处理 3
[2, 4, 6]

map 里那个 println! 在声明那一行一个都没跑 —— 它们全都推迟到了 collect() 那一刻。

对照项干脆不 collect，于是一条「处理」都没打印。

⇒ 迭代器链只是在搭一个配方。真正跑起来要靠消费者：

⚠️ 实际后果：v.iter().map(|x| println!("{x}")); 这一行什么都不做， 而编译器只会给一个「未使用」的警告。想执行就得用 for_each 或者 for。

iter / iter_mut / into_iter

三个名字对应三种所有权关系，和借用那一章完全对得上：

用了 into_iter() 之后再用容器就是 E0382。

⇒ 记法：名字里带 into 就是要所有权。标准库里到处如此 （into_inner、into_bytes、into_boxed_slice…）。

📌 for x in &v / for x in &mut v / for x in v 分别是上面三个的语法糖。

三个 Fn trait

闭包实现哪个 trait 不是你声明的，是编译器按它对环境做了什么推出来的：

它们是包含关系：Fn ⊂ FnMut ⊂ FnOnce。 一个 Fn 闭包可以喂给要求 FnMut 的地方，反过来不行 —— 对照项那个改了 count 的闭包只是 FnMut，塞不进要求 Fn 的参数里：

error[E0594]: cannot assign to `count`, as it is a captured variable in a `Fn` closure
  | fn call_twice<F: Fn() -> i32>(f: F) -> i32 { f() + f() }
  |                                  - change this to accept `FnMut` instead of `Fn`

⭐ 注意最后那一行 —— 编译器直接指着函数签名告诉你该怎么改。

⇒ 写参数时的判据：能写 Fn 就写 Fn —— 限制最松的那个对调用方最友好。 需要调用方改状态才放宽到 FnMut，需要消耗掉才用 FnOnce。

move：把环境搬进去

默认情况下闭包借用环境。加 move 就变成拿走所有权， 之后原变量就不能用了（E0382）。

⇒ 什么时候必须写：闭包要活得比当前作用域久的时候 —— 丢给线程、存进结构体、当返回值。不写的话编译器会直接提醒你。

迭代器链和手写循环

两边算出同一个数。语义上它们是等价的： 迭代器链不会引入额外的中间集合，filter 不会先生成一个新 Vec 再给 map。

⚠️ 但「性能也一样」这句话本站不做断言 —— 那需要测， 而同一份代码在不同机器上能给出相反的结论。 （本板块一个耗时数字都不给，理由见闸门那边。）

能说的只有语义。至于可读性，那是风格问题：

• 链式在「一串变换」时更清楚；
• 手写循环在「中途要 break、要提前返回、要同时改好几个变量」时更清楚。

常用适配器速查

⭐ 标准库里这七十多个方法全是默认方法， 只要实现一个 next 就全都有了 —— 见泛型与 trait 那篇。 自己写一个迭代器的成本因此低得出奇。

下一步

最后一篇：《并发与 Send / Sync》。 「无畏并发」这句口号的实际含义是数据竞争是编译错误 —— 而它用的不是什么新机制，就是所有权和借用那两套规则。

全部篇目见 Rust 教程首页。

fn main() {
    let v = vec![1, 2, 3];
    let it = v.iter().map(|x| {
        println!("处理 {x}");
        x * 2
    });
    println!("还没开始");
    let out: Vec<i32> = it.collect();
    println!("{out:?}");
}

fn main() {
    let v = vec![1, 2, 3];
    let _it = v.iter().map(|x| {
        println!("处理 {x}");
        x * 2
    });
    println!("还没开始");
}

fn main() {
    let mut v = vec![1, 2, 3];
    let s: i32 = v.iter().sum();
    for x in v.iter_mut() {
        *x *= 10;
    }
    let owned: Vec<i32> = v.into_iter().filter(|x| *x > 10).collect();
    println!("{s} {owned:?}");
}

fn main() {
    let mut v = vec![1, 2, 3];
    let s: i32 = v.iter().sum();
    for x in v.iter_mut() {
        *x *= 10;
    }
    let owned: Vec<i32> = v.into_iter().filter(|x| *x > 10).collect();
    println!("{s} {owned:?} {}", v.len());
}

fn call_twice<F: Fn() -> i32>(f: F) -> i32 {
    f() + f()
}

fn main() {
    let base = 10;
    println!("{}", call_twice(|| base));
}

fn call_twice<F: Fn() -> i32>(f: F) -> i32 {
    f() + f()
}

fn main() {
    let mut count = 0;
    println!("{}", call_twice(|| {
        count += 1;
        count
    }));
}

fn main() {
    let s = String::from("hi");
    let f = move || s.len();
    println!("{}", f());
}

fn main() {
    let s = String::from("hi");
    let f = move || s.len();
    println!("{} {}", f(), s.len());
}

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    let a: i32 = v.iter().filter(|x| *x % 2 == 0).map(|x| x * x).sum();
    let mut b = 0;
    for x in &v {
        if x % 2 == 0 {
            b += x * x;
        }
    }
    println!("{a} {b}");
}

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    let a = v.iter().filter(|x| *x % 2 == 0).map(|x| x * x).count();
    let mut b = 0;
    for x in &v {
        if x % 2 == 0 {
            b += x * x;
        }
    }
    println!("{a} {b}");
}