Rust中的函数式编程：惯用法与实践

Rust 中的函数式编程：从迭代器到函子

Rust 是一种多范式语言，它无缝融合了命令式、面向对象和函数式风格。尽管 Rust 并非纯粹的函数式语言（如 Haskell），但其类型系统和所有权模型允许以函数式风格编写优雅、安全且富有表现力的代码。在本文中，我们将剖析 Rust 中函数式编程 (FP) 的关键概念：闭包、迭代器、模式匹配以及 Option 和 Result 的使用。本材料适用于希望深入了解 Rust 函数式能力的初学者和经验丰富的开发者。

闭包与 Lambda 表达式

Rust 中的闭包是可以从其周围作用域捕获变量的匿名函数。它们是函数式方法的基础，允许将行为作为数据进行传递。

闭包的语法简洁：|参数| 主体。闭包可以作为参数传递给函数、存储在变量中以及从函数返回。记住控制捕获的三个 trait 很重要：Fn（借用）、FnMut（可变借用）和 FnOnce（消费）。

fn main() {    // 简单闭包    let add_one = |x: i32| x + 1;    println!("{}", add_one(5)); // 6

    // 捕获变量    let factor = 10;    let multiply = |x| x * factor;    println!("{}", multiply(3)); // 30

    // 带有 FnOnce trait 的闭包    let name = String::from("Rust");    let greet = move || {        println!("Hello, {}!", name); // name 被移动    };    greet();    // println!("{}", name); // 错误！name 不再可用}

move 关键字强制按值捕获（移动），这在处理多线程或将闭包传递给其它上下文时通常是必要的。

迭代器：惰性处理与方法链

Rust 中函数式风格最强大的方面之一是其强大的迭代器适配器。您不需要显式的 for 循环和变量修改，而是使用方法链：map、filter、fold、collect 等。Rust 中的迭代器是惰性的——它们在调用消费方法（例如 collect() 或 for_each()）之前不会执行计算。

fn main() {    let numbers = vec![1, 2, 3, 4, 5, 6];

    // 函数式方法：过滤与转换    let result: Vec<i32> = numbers        .iter()                 // 创建一个迭代器        .filter(|&x| x % 2 == 0) // 只保留偶数        .map(|x| x * x)         // 求平方        .collect();             // 收集到向量中

    println!("{:?}", result); // [4, 16, 36]

    // 使用 fold 求和（归约）    let sum = numbers.iter().fold(0, |acc, x| acc + x);    println!("Sum: {}", sum); // 21

    // 使用 any 和 all 进行条件检查    let has_even = numbers.iter().any(|x| x % 2 == 0);    println!("Has even numbers: {}", has_even); // true}

使用迭代器使代码具有声明性、可读性，并且不易出现与索引和数组边界相关的错误。Rust 编译器通常会将迭代器链优化为与手动循环相当的高效机器代码。

模式匹配与解构

模式匹配 (match) 是 Rust 中函数式流程控制的核心。它允许安全地处理数据的所有可能变体，尤其是在与代数数据类型（enum）结合使用时。模式可以嵌套、包含守卫，并且可以解构结构体、元组和枚举。

enum Message {    Quit,    Move { x: i32, y: i32 },    Write(String),    ChangeColor(i32, i32, i32),}

fn handle_