13.3 闭包 Pt.3使用泛型参数和fn trait来存储闭包13.3.0. 写在正文之前Rust语言在设计过程中受到了很多语言的启发而函数式编程对Rust产生了非常显著的影响。函数式编程通常包括通过将函数作为值传递给参数、从其他函数返回它们、将它们分配给变量以供以后执行等等。在本章中我们会讨论 Rust 的一些特性这些特性与许多语言中通常称为函数式的特性相似-闭包本文- 迭代器- 使用闭包和迭代器改进I/O项目- 闭包和迭代器的性能13.3.1. 回顾还记得在 13.1 中的例子吗做一个程序根据人的身体指数等因素生成自定义的运动计划。这个程序的算法逻辑并不是重点重点是算法在计算过程中会花费几秒的时间。我们的目标是不让用户发生不必要的等待。具体来说就是仅在必要的时候才调用该算法而且只调用一次。当时我们修改代码为use std::thread; use std::time::Duration; fn main() { let simulated_user_specified_value 10; let simulated_random_number 7; generate_workout( simulated_user_specified_value, simulated_random_number, ); } fn generate_workout(intensity: u32, random_number: u32) { let expensive_closure |num| { println!(calculating slowly...); thread::sleep(Duration::from_secs(2)); num }; if intensity 25 { println!(Today, do {} pushups!, expensive_closure(intensity)); println!(Next, do {} situps!, expensive_closure(intensity)); } else { if random_number 3 { println!(Take a break today! Remember to stay hydrated!); } else { println!(Today, run for {} minutes!, expensive_closure(intensity)); } } }但是还存在一个问题这么写没有解决闭包重复调用的问题。在intensity小于25的情况下调用了2次闭包。对于这个问题一个解决方案是把闭包的值赋给某个本地变量让这个本地变量被输出语句重复调用。这么写问题的是会造成一些代码的重复。所以这里更适合使用另一种解决方法创建一个结构体它持有闭包及其调用结果。也就是说在第一次调用闭包后把结果存到闭包持有者里如果以后还要调用闭包就直接使用缓存的结果。它的效果是只会在需要结果时才执行该闭包而且可缓存结果。这种模式通常叫记忆化memoization或延迟计算lazy evaluation13.3.2. 让结构体持有闭包根据刚才的解决方法目前的问题在于如何让结构体持有闭包。结构体的定义需要知道所有字段的类型所以如果想在结构体内存储闭包就必须指明闭包的类型。每个闭包实例都有自己唯一的匿名类型即使两个闭包签名完全一样这两个实例仍然是两个类型。所以存储闭包需要使用泛型以及trait bound泛型和trait bound的内容在 10.4. trait Pt.2 中有讲推荐看看这篇13.3.3.Fn traitFn trait由标准库提供。所有的闭包都至少实现了以下Fn trait之一-Fn-FnMut-FnOnce这三个Fn trait间的区别会在下一篇文章讲到。在本例中使用Fn就可以了。知道这些之后就可以修改例子了。首先创建一个结构体:struct CacheT: Fn(u32) - u32 { calculation: T, value: Optionu32, }这个结构体有一个泛型参数T由于它代表的是闭包的类型它的约束是Fntrait在本例中使用Fn就可以了,然后参数和返回值是u32所以写Fn(u32) - u32。闭包所在的字段是calculation它的类型就是T要缓存的值在value字段上其类型是u32但是要注意的是不清楚这个值是否已经计算出来并缓存在里面了所以要用Option类型来包裹也就是Optionu32。先在结构体上写一个构造函数用于创建实例implT: Fn(u32) - u32 CacheT { fn new(calculation: T) - CacheT { Cache { calculation, value: None, } } }这么写看着有点乱可以用where子句重写一下implT CacheT where T: Fn(u32) - u32 { fn new(calculation: T) - CacheT { Cache { calculation, value: None, } } }然后为了实现value有值就取value下的值value是None就计算的功能再写一个函数fn value(mut self, arg: u32) - u32 { match self.value { Some(v) v, None { let v (self.calculation)(arg); self.value Some(v); v } } }如果实例的value字段有值就返回这个值没有值就计算出这个值存储在value字段里再返回。这部分写好之后就该把generate_workout的写法改一下转为使用cache结构体fn generate_workout(intensity: u32, random_number: u32) { let mut expensive_closure Cache::new(|num|{ println!(calculating slowly...); thread::sleep(Duration::from_secs(2)); num }); if intensity 25 { println!(Today, do {} pushups!, expensive_closure.value(intensity)); println!(Next, do {} situps!, expensive_closure.value(intensity)); } else { if random_number 3 { println!(Take a break today! Remember to stay hydrated!); } else { println!(Today, run for {} minutes!, expensive_closure.value(intensity)); } } }把expensive_closure作为Cache结构体的实例使用new函数把闭包传进去。这里把expensive_closure加上mut设为可变绑定是因为后文调用时可能会改变value这个字段的值。下文所有要使用值的操作都使用value方法来获取。13.3.4. 使用缓存器实现的限制这里的Cache字段就是缓存器用于缓存某个值但这么写是有限制的。我把Cache的声明和其方法的代码贴在这里struct CacheT: Fn(u32) - u32 { calculation: T, value: Optionu32, } implT CacheT where T: Fn(u32) - u32 { fn new(calculation: T) - CacheT { Cache { calculation, value: None, } } fn value(mut self, arg: u32) - u32 { match self.value { Some(v) v, None { let v (self.calculation)(arg); self.value Some(v); v } } } }value这个方法总会得到同样的值如果value字段没有值那它就会计算出值然后把值存储在value字段里之后的其他地方使用value就会得到最开始的计算的这个值不论传进去的参数是什么。这么说可能有点模糊那来看个例子fn call_with_different_values(){ let mut c Cache::new(|a| a); let v1 c.value(1); let v2 c.value(2); }c是Cache的一个实例传进去了一个闭包。在let v1 c.value(1);这一行时原本c的value字段没有值这时候传进去个1value字段就变成Some(1)了(value字段是Option类型)在let v2 c.value(2);这一行时由于value字段原本有值所以会直接取value字段的1赋给v2即使这行的value方法的参数与上一行不一样。如果不想要这样就得使用HashMap来代替单个的值把HashMap的key作为value方法传进去的参数args而值就作为执行闭包的结果。比如说struct ForFunT: Fn(u32) - u32 { calculation: T, value: HashMapu32, Optionu32, } implT ForFunT where T: Fn(u32) - u32 { fn new(calculation: T) - ForFunT { ForFun { calculation, value: HashMap::new(), } } fn value(mut self, arg: u32) - u32 { match self.value.get(arg) { Some(v) v.unwrap(), None { let v (self.calculation)(arg); self.value.insert(arg, Some(v)); v } } } }这个例子中的缓存器只能接受同样的参数类型和返回值类型。如果想让闭包的参数类型和返回值类型不一样就可以引入两个及以上的泛型参数。比如说struct ForFunT, R where T: Fn(u32) - R, { calculation: T, value: OptionR, }