【Rust自学】13.3. 闭包 Pt.3：使用泛型参数和fn trait来存储闭包

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 evaluation）

13.3.2. 让结构体持有闭包

根据刚才的解决方法，目前的问题在于如何让结构体持有闭包。

结构体的定义需要知道所有字段的类型，所以如果想在结构体内存储闭包，就必须指明闭包的类型。

每个闭包实例都有自己唯一的匿名类型，即使两个闭包签名完全一样，这两个实例仍然是两个类型。所以存储闭包需要使用泛型以及trait bound（泛型和trait bound的内容在 10.4. trait Pt.2 中有讲，推荐看看这篇）

13.3.3.Fn trait

Fn trait由标准库提供。所有的闭包都至少实现了以下Fn trait之一：
-Fn
-FnMut
-FnOnce

这三个Fn trait间的区别会在下一篇文章讲到。在本例中使用Fn就可以了。

知道这些之后就可以修改例子了。首先创建一个结构体:

struct Cache<T: Fn(u32) -> u32> { calculation: T, value: Option<u32>, }
  • 这个结构体有一个泛型参数T，由于它代表的是闭包的类型，它的约束是Fntrait（在本例中使用Fn就可以了）,然后参数和返回值是u32，所以写Fn(u32) -> u32。
  • 闭包所在的字段是calculation，它的类型就是T
  • 要缓存的值在value字段上，其类型是u32，但是要注意的是不清楚这个值是否已经计算出来并缓存在里面了，所以要用Option类型来包裹，也就是Option<u32>。

先在结构体上写一个构造函数用于创建实例：

impl<T: Fn(u32) -> u32> Cache<T> { fn new(calculation: T) -> Cache<T> { Cache { calculation, value: None, } } }

这么写看着有点乱，可以用where子句重写一下：

impl<T> Cache<T> where T: Fn(u32) -> u32 { fn new(calculation: T) -> Cache<T> { 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 Cache<T: Fn(u32) -> u32> { calculation: T, value: Option<u32>, } impl<T> Cache<T> where T: Fn(u32) -> u32 { fn new(calculation: T) -> Cache<T> { 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字段没有值，这时候传进去个1，value字段就变成Some(1)了(value字段是Option类型)

  • 在let v2 = c.value(2);这一行时由于value字段原本有值，所以会直接取value字段的1赋给v2，即使这行的value方法的参数与上一行不一样。

如果不想要这样，就得使用HashMap来代替单个的值，把HashMap的key作为value方法传进去的参数args；而值就作为执行闭包的结果。比如说：

struct ForFun<T: Fn(u32) -> u32> { calculation: T, value: HashMap<u32, Option<u32>>, } impl<T> ForFun<T> where T: Fn(u32) -> u32 { fn new(calculation: T) -> ForFun<T> { 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 ForFun<T, R> where T: Fn(u32) -> R, { calculation: T, value: Option<R>, }