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

🕗 发布于 2025-01-20 15:32 rust 开发语言 后端重构

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次闭包。

对于这个问题，一个解决方案是把闭包的值赋给某个本地变量，让这个本地变量被输出语句重复调用。这么写问题的是会造成一些代码的重复。

所以这里更适合使用另一种解决方法：创建一个结构体，它持有闭包及其调用结果。也就是说，在第一次调用闭包后把结果存到闭包里，如果以后还要调用闭包就直接使用存在里面的结果。它的效果是只会在需要结果时才执行该包，而且可缓存结果。

这种模式通常叫 记忆化(memorization) 或 延迟计算(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，由于它代表的是闭包的类型，它的约束是Fn trait（在本例中使用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>,  
}

原文地址：https://blog.csdn.net/weixin_71793197/article/details/145201498

免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：【Rust自学】13.8. 迭代器 Pt.4：创建自定义迭代器
下一篇：# Rust Actix Web 入门指南

项目练习：若依系统数据导出功能-Vue前端部分
项目练习
阅读更多2025-01-21
AI 编程工具—Cursor 对话模式详解 Chat、Composer 与 Normal/Agent 模式
Chat 模式适合快速交互和问题解答Composer 模式适合结构化代码生成Normal/Agent 模式提供了不同层次的问题解决能力选择合适的模式，配合清晰的提示词，能够让 AI 助手发挥最大价值。
阅读更多2025-01-21
解决Spring Boot中Druid连接池“discard long time none received connection“警告
虽然"discard long time none received connection"的警告可能不会直接影响应用程序的运行，但解决这个问题可以提高应用程序的稳定性，并减少不必
阅读更多2025-01-21
面试-业务逻辑2
给定2个数组a、b，若a[i]==b[j]，则记(i,j)为一个二元数组，求具体的二元数组及其个数。
阅读更多2025-01-21
c# 设置Regex Multiline无效问题
始终忽略任何回车(\r)。若要使用\r\n或\n结束RegexOptions.Multiline匹配，请使用子表达式\r?设置RegexOptions.Multiline后正则中$可匹配每一行的结束符
阅读更多2025-01-21
【MathType】mathtype在word中格式问题
Ctrl+C：选中全部——>段落——>设置为单倍行距。Ctrl+C：选中所有文章——>段落——>取消勾选。含有公式的文字段落行距太大，比都是文字的段落大。已经可以全部显示出来，
阅读更多2025-01-21
Mono里运行C#脚本28—mono_create_jit_trampoline
它的主要作用是为指定的 C 函数创建调用代码，接收一个描述 C 函数的参数和返回类型的monomethod，并创建调用该函数的代码。- 它们调用 `mono_class_init_trampoline
阅读更多2025-01-21
MySQL-事务
事务是面试中常考到的概念
阅读更多2025-01-21
24.C语言标准库函数（中）
本文介绍了C语言中的stdint.h和stdlib.h头文件。stdint.h提供了固定宽度整数类型的别名，如int8_t和uint32_t，确保跨平台的一致性。stdlib.h定义了基本数据类型和一
阅读更多2025-01-21
CSS 动画相关属性
一些CSS属性可用于动画制作，这意味着它们可用于过渡等效果中。可设置动画的属性可以从一个值逐渐更改为另一个值，例如尺寸、数字、百分比和颜色。
阅读更多2025-01-21