十五、迭代器 (Iterators) 与闭包 (Closures)

迭代器和闭包是Rust函数式编程的核心概念，它们提供了强大的抽象能力，可以编写既高效又表达力强的代码。

1. 闭包(Closures)

闭包是可以捕获其环境的匿名函数，在Rust中也被称为lambda表达式。

1.1 基本语法

fn main() {
    // 基本闭包
    let add_one = |x| x + 1;
    println!("5 + 1 = {}", add_one(5));
    
    // 多参数闭包
    let add = |a, b| a + b;
    println!("3 + 4 = {}", add(3, 4));
    
    // 多行闭包
    let complex_closure = |x: i32| -> i32 {
        let y = x * 2;
        y + 1
    };
    println!("5 -> {}", complex_closure(5));
}

1.2 捕获环境

fn main() {
    let base = 10;
    
    // 闭包捕获外部变量base
    let add_base = |x| x + base;
    
    println!("5 + base = {}", add_base(5)); // 15
    
    // 移动语义捕获 (使用move关键字)
    let s = String::from("hello");
    let print_s = move || println!("{}", s);
    print_s();
    // println!("{}", s); // 错误，s的所有权已被移动
}

1.3 闭包类型推断

fn main() {
    // 第一次调用确定参数和返回类型
    let example_closure = |x| x;
    let s = example_closure(String::from("hello"));
    // let n = example_closure(5); // 错误，类型已推断为String
}

1.4 闭包trait

Rust闭包实际上实现了以下trait之一：

Fn：不可变借用捕获环境
FnMut：可变借用捕获环境
FnOnce：获取所有权捕获环境

fn call_with_one<F>(closure: F) -> i32
where
    F: Fn(i32) -> i32,
{
    closure(1)
}

fn main() {
    let answer = call_with_one(|x| x + 2);
    println!("{}", answer); // 3
}

2. 迭代器(Iterators)

迭代器是Rust中处理集合的抽象，提供了一种高效、安全的方式来遍历元素。

2.1 基本使用

fn main() {
    let v1 = vec![1, 2, 3];
    
    // 创建迭代器
    let v1_iter = v1.iter();
    
    // 使用迭代器
    for val in v1_iter {
        println!("Got: {}", val);
    }
    
    // 迭代器是惰性的，只有消费时才会实际计算
    let v2 = vec![4, 5, 6];
    v2.iter().for_each(|x| println!("{}", x));
}

2.2 迭代器trait

所有迭代器都实现了std::iter::Iterator trait：

pub trait Iterator {
    type Item;  // 关联类型
    
    fn next(&mut self) -> Option<Self::Item>;
    
    // 许多默认方法
}

2.3 消费迭代器的方法

fn main() {
    let v1 = vec![1, 2, 3];
    
    // sum消费迭代器
    let total: i32 = v1.iter().sum();
    println!("Total: {}", total);
    
    // collect转换为新集合
    let v2: Vec<_> = v1.iter().map(|x| x + 1).collect();
    println!("v2: {:?}", v2);
    
    // any检查是否有元素满足条件
    let has_gt_two = v1.iter().any(|&x| x > 2);
    println!("Has >2: {}", has_gt_two);
}

2.4 产生新迭代器的方法