Rust 函数式编程详解

Rust 函数式编程详解

闭包（Closures）

闭包语法

// 基本闭包语法
let add = |x, y| x + y;
let result = add(5, 3); // 8

// 显式类型标注
let multiply: fn(i32, i32) -> i32 = |x, y| x * y;

// 多行闭包
let complex_closure = |x| {
    let y = x * 2;
    y + 1
};

捕获环境

fn main() {
    let x = 4;
    
    // 不可变捕获
    let equal_to_x = |z| z == x;
    println!("结果：{}", equal_to_x(4)); // true
    
    // 可变捕获
    let mut factor = 2;
    let mut multiplier = || {
        factor *= 2;
        factor
    };
    
    println!("倍增：{}", multiplier()); // 4
    println!("倍增：{}", multiplier()); // 8
}

闭包类型推断

// 编译器自动推断闭包类型
let add = |x, y| x + y;

// 等价于
let add: fn(i32, i32) -> i32 = |x: i32, y: i32| -> i32 { x + y };

闭包作为参数和返回值

// 接受闭包作为参数
fn apply<F>(f: F, value: i32) -> i32
where 
    F: Fn(i32) -> i32 
{
    f(value)
}

// 返回闭包
fn create_multiplier(factor: i32) -> Box<dyn Fn(i32) -> i32> {
    Box::new(move |x| x * factor)
}

fn main() {
    let double = |x| x * 2;
    println!("应用：{}", apply(double, 5)); // 10
    
    let triple = create_multiplier(3);
    println!("创建的乘数：{}", triple(4)); // 12
}

迭代器

迭代器特征

// 迭代器基本特征
trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}

// 创建迭代器
let v = vec![1, 2, 3, 4, 5];
let mut iter = v.iter();

// 手动迭代
while let Some(item) = iter.next() {
    println!("{}", item);
}

迭代器适配器

let numbers = vec![1, 2, 3, 4, 5];

// map 适配器：转换元素
let squared: Vec<i32> = numbers
    .iter()
    .map(|&x| x * x)
    .collect();

// filter 适配器：过滤元素
let even: Vec<i32> = numbers
    .into_iter()
    .filter(|&x| x % 2 == 0)
    .collect();

// 链式调用
let result: Vec<i32> = numbers
    .iter()
    .map(|&x| x * 2)
    .filter(|&x| x > 6)
    .collect();

消费适配器

let numbers = vec![1, 2, 3, 4, 5];

// sum：求和
let total: i32 = numbers.iter().sum();

// fold：自定义累加
let product = numbers.iter().fold(1, |acc, &x| acc * x);

// any/all：条件检查
let has_even = numbers.iter().any(|&x| x % 2 == 0);
let all_positive = numbers.iter().all(|&x| x > 0);

自定义迭代器

// 自定义计数迭代器
struct Counter {
    count: usize,
}

impl Counter {
    fn new() -> Counter {
        Counter { count: 0 }
    }
}

impl Iterator for Counter {
    type Item = usize;
    
    fn next(&mut self) -> Option<Self::Item> {
        self.count += 1;
        if self.count < 6 {
            Some(self.count)
        } else {
            None
        }
    }
}

fn main() {
    let counter = Counter::new();
    let sum: usize = counter
        .take(5)
        .map(|x| x * x)
        .sum();
    
    println!("平方和：{}", sum);
}

函数式编程模式

管道模式

fn process_data(data: &[i32]) -> Vec<i32> {
    data.iter()
        .filter(|&&x| x > 0)
        .map(|&x| x * 2)
        .collect()
}

高阶函数

fn apply_twice<F>(f: F, x: i32) -> i32
where 
    F: Fn(i32) -> i32 
{
    f(f(x))
}

fn main() {
    let result = apply_twice(|x| x + 1, 5); // 7
}

最佳实践

1. 优先使用迭代器而非显式循环
2. 利用闭包进行函数式转换
3. 使用链式调用提高可读性
4. 注意闭包的捕获和所有权
5. 选择合适的迭代器适配器

结语

Rust 的函数式编程特性提供了强大的抽象能力，同时保持了高性能和内存安全。通过闭包和迭代器，你可以编写更加简洁、表达力强的代码。持续实践是掌握这些技术的关键。