闭包
闭包是一种匿名函数，它可以赋值给变量也可以作为参数传递给其它函数，不同于函数的是，它允许捕获调用者作用域中的值，例如：
fn main() { let x = 1; let sum = |y| x + y; assert_eq!(3, sum(2)); }
上面的代码展示了非常简单的闭包 sum，它拥有一个入参 y，同时捕获了作用域中的 x 的值，因此调用 sum(2) 意味着将 2（参数 y）跟 1（x）进行相加,最终返回它们的和：3。
可以看到 sum 非常符合闭包的定义：可以赋值给变量，允许捕获调用者作用域中的值。
使用闭包来简化代码
传统函数实现
想象一下，我们要进行健身，用代码怎么实现,这里是我的想法：
use std::thread; use std::time::Duration; // 开始健身，好累，我得发出声音：muuuu... fn muuuuu(intensity: u32) -> u32 { println!("muuuu....."); thread::sleep(Duration::from_secs(2)); intensity } fn workout(intensity: u32, random_number: u32) { if intensity < 25 { println!( "今天活力满满，先做 {} 个俯卧撑!", muuuuu(intensity) ); println!( "旁边有妹子在看，俯卧撑太low，再来 {} 组卧推!", muuuuu(intensity) ); } else if random_number == 3 { println!("昨天练过度了，今天还是休息下吧！"); } else { println!( "昨天练过度了，今天干干有氧，跑步 {} 分钟!", muuuuu(intensity) ); } } fn main() { // 强度 let intensity = 10; // 随机值用来决定某个选择 let random_number = 7; // 开始健身 workout(intensity, random_number); }
可以看到，在健身时我们根据想要的强度来调整具体的动作，然后调用 muuuuu 函数来开始健身。这个程序本身很简单，没啥好说的，但是假如未来不用 muuuuu 函数了，是不是得把所有 muuuuu 都替换成，比如说 woooo ？如果 muuuuu 出现了几十次，那意味着我们要修改几十处地方。
闭包实现
use std::thread; use std::time::Duration; fn workout(intensity: u32, random_number: u32) { let action = || { println!("muuuu....."); thread::sleep(Duration::from_secs(2)); intensity }; if intensity < 25 { println!( "今天活力满满，先做 {} 个俯卧撑!", action() ); println!( "旁边有妹子在看，俯卧撑太low，再来 {} 组卧推!", action() ); } else if random_number == 3 { println!("昨天练过度了，今天还是休息下吧！"); } else { println!( "昨天练过度了，今天干干有氧，跑步 {} 分钟!", action() ); } } fn main() { // 动作次数 let intensity = 10; // 随机值用来决定某个选择 let random_number = 7; FnOnce，该类型的闭包会拿走被捕获变量的所有权。Once 顾名思义，说明该闭包只能运行一次： // 开始健身 workout(intensity, random_number); }
在上面代码中，无论你要修改什么，只要修改闭包 action 的实现即可，其它地方只负责调用，完美解决了我们的问题！
Rust 闭包在形式上借鉴了 Smalltalk 和 Ruby 语言，与函数最大的不同就是它的参数是通过 |parm1| 的形式进行声明，如果是多个参数就 |param1, param2,…|， 下面给出闭包的形式定义：
|param1, param2,...| { 语句1; 语句2; 返回表达式 }
闭包的类型推导
与函数相反，闭包并不会作为 API 对外提供，因此它可以享受编译器的类型推导能力，无需标注参数和返回值的类型。
下面展示了同一个功能的函数和闭包实现形式：
fn add_one_v1 (x: u32) -> u32 { x + 1 } let add_one_v2 = |x: u32| -> u32 { x + 1 }; let add_one_v3 = |x| { x + 1 }; let add_one_v4 = |x| x + 1 ;
虽然类型推导很好用，但是它不是泛型，当编译器推导出一种类型后，它就会一直使用该类型：
let example_closure = |x| x; let s = example_closure(String::from("hello")); let n = example_closure(5);
首先，在 s 中，编译器为 x 推导出类型 String，但是紧接着 n 试图用 5 这个整型去调用闭包，跟编译器之前推导的 String 类型不符，因此报错：
error[E0308]: mismatched types --> src/main.rs:5:29 | 5 | let n = example_closure(5); | ^ | | | expected struct `String`, found integer // 期待String类型，却发现一个整数 | help: try using a conversion method: `5.to_string()`
结构体中的闭包
假设我们要实现一个简易缓存，功能是获取一个值，然后将其缓存起来，那么可以这样设计：
- 一个闭包用于获取值
- 一个变量，用于存储该值
可以使用结构体来代表缓存对象，最终设计如下：
struct Cacher<T> where T: Fn(u32) -> u32, { query: T, value: Option<u32>, }
