第13章 函数式语言特性

函数式编程是一种强大的编程范式，它强调不可变性、纯函数和声明式代码。Rust从函数式语言中汲取了许多灵感，提供了闭包、迭代器等强大的函数式特性。这些特性与Rust的所有权系统完美结合，使得我们能够编写出既安全又富有表现力的代码。本章将深入探讨Rust的函数式编程能力，包括闭包、迭代器、函数式模式以及性能分析。

13.1 闭包：捕获环境的匿名函数

闭包基础与语法

闭包是可以捕获其所在环境的匿名函数。它们与普通函数不同，能够访问定义它们的作用域中的变量。

基本闭包语法

fn closure_basics() {
    // 最简单的闭包 - 没有参数，没有返回值
    let greet = || println!("Hello, world!");
    greet();
    
    // 带参数的闭包
    let add = |a, b| a + b;
    println!("3 + 5 = {}", add(3, 5));
    
    // 多行闭包
    let complex_operation = |x: i32| {
        let intermediate = x * 2;
        intermediate + 10
    };
    println!("Complex operation result: {}", complex_operation(5));
    
    // 闭包类型推断
    let example_closure = |x| x;
    let s = example_closure(String::from("hello"));
    // 下面这行会编译错误，因为闭包类型已经被推断为接收String
    // let n = example_closure(5);
}

环境捕获

闭包最强大的特性是能够捕获其定义环境中的变量：

fn environment_capture() {
    let base_value = 10;
    
    // 捕获不可变引用
    let add_base = |x| x + base_value;
    println!("5 + base = {}", add_base(5));
    println!("base_value is still accessible: {}", base_value);
    
    // 捕获可变引用
    let mut counter = 0;
    let mut increment = || {
        counter += 1;
        println!("Counter: {}", counter);
    };
    
    increment();
    increment();
    increment();
    
    // 移动语义捕获
    let expensive_data = vec![1, 2, 3, 4, 5];
    let consume_data = move || {
        println!("Consuming data: {:?}", expensive_data);
        // expensive_data 的所有权被移动进闭包
    };
    
    consume_data();
    // println!("{:?}", expensive_data); // 这行会编译错误，因为所有权已经移动
}

闭包trait：Fn、FnMut、FnOnce

Rust根据闭包如何使用捕获的变量，为它们自动实现不同的trait：

fn closure_traits_demo() {
    // Fn - 不可变借用环境变量
    let x = 5;
    let print_x = || println!("x = {}", x);
    print_x();
    println!("x is still available: {}", x);
    
    // FnMut - 可变借用环境变量
    let mut y = 10;
    let mut add_to_y = || {
        y += 5;
        println!("y = {}", y);
    };
    add_to_y();
    // println!("y = {}", y); // 这里还不能访问，因为闭包还持有可变引用
    
    // FnOnce - 获取环境变量的所有权
    let z = vec![1, 2, 3];
    let consume_z = move || {
        println!("Consuming z: {:?}", z);
        // z 的所有权被移动
    };
    consume_z();
    // println!("{:?}", z); // 编译错误
    
    // 演示不同trait的使用
    fn call_fn<F: Fn()>(f: F) {
        f();
    }
    
    fn call_fn_mut<F: FnMut()>(mut f: F) {
        f();
    }
    
    fn call_fn_once<F: FnOnce()>(f: F) {
        f();
    }
    
    let immutable_closure = || println!("I'm Fn");
    let mut data = 0;
    let mut mutable_closure = || {
        data += 1;
        println!("I'm FnMut, data = {}", data);
    };
    let owned_closure = move || println!("I'm FnOnce, moved data");
    
    call_fn(immutable_closure);
    call_fn_mut(mutable_closure);
    call_fn_once(owned_closure);
}

闭包的实际应用

回调函数

struct EventHandler<F>
where
    F: Fn(&str),
{
    callback: F,
}

impl<F> EventHandler<F>
where
    F: Fn(&str),
{
    fn new(callback: F) -> Self {
        EventHandler { callback }
    }
    
    fn handle_event(&self, event: &str) {
        (self.callback)(event);
    }
}

fn callback_demo() {
    let prefix = "Event: ";
    let handler = EventHandler::new(|event| {
        println!("{}{}", prefix, event);
    });
    
    handler.handle_event("click");
    handler.handle_event("hover");
    handler.handle_event("keypress");
}

配置化行为

struct DataProcessor<F>
where
    F: Fn(i32) -> i32,
{
    processor: F,
}

impl<F> DataProcessor<F>
where
    F: Fn(i32) -> i32,
{
    fn new(processor: F) -> Self {
        DataProcessor { processor }
    }
    
    fn process_data(&self, data: &[i32]) -> Vec<i32> {
        data.iter().map(|&x| (self.processor)(x)).collect()
    }
}

fn configurable_behavior_demo() {
    let numbers = vec![1, 2, 3, 4, 5];
    
    // 创建不同的处理器
    let doubler = DataProcessor::new(|x| x * 2);
    let squarer = DataProcessor::new(|x| x * x);
    let incrementer = DataProcessor::new(|x| x + 10);
    
    println!("Original: {:?}", numbers);
    println!("Doubled: {:?}", doubler.process_data(&numbers));
    println!("Squared: {:?}", squarer.process_data(&numbers));
    println!("Incremented: {:?}", incrementer.process_data(&numbers));
    
    // 使用环境捕获的闭包
    let multiplier = 3;
    let custom_multiplier = DataProcessor::new(move |x| x * multiplier);
    println!("Custom multiplied: {:?}", custom_multiplier.process_data(&numbers));
}

闭包与生命周期

闭包的生命周期行为需要特别注意：

fn closure_lifetimes() {
    // 简单的生命周期示例
    let string = String::from("hello");
    
    // 闭包捕获了 string 的引用
    let print_string = || {
        println!("String: {}", string);
    };
    
    print_string();
    println!("Original string: {}", string); // 仍然可以访问
    
    // 更复杂的生命周期场景
    fn create_processor<'a, F>(data: &'a [i32], processor: F) -> impl Fn() -> Vec<i32> + 'a
    where
        F: Fn(&i32) -> i32 + 'a,
    {
        move || data.iter().map(&processor).collect()
    }
    
    let numbers = vec![1, 2, 3, 4, 5];
    let factor = 2;
    
    let processor = create_processor(&numbers, |x| x * factor);
    let result = processor();
    println!("Processed: {:?}", result);
    
    // 返回闭包的函数
    fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
        move |y| x + y
    }
    
    let add_five = make_adder(5);
    let add_ten = make_adder(10);
    
    println!("5 + 3 = {}", add_five(3));
    println!("10 + 3 = {}", add_ten(3));
}

13.2 迭代器处理元素序列

迭代器基础

迭代器是Rust中处理集合元素的强大工具，它们提供了一种统一的方式来遍历各种数据结构。

创建迭代器

fn iterator_creation() {
    let vec = vec![1, 2, 3, 4, 5];
    
    // 不同类型的迭代器
    let iter = vec.iter();          // 不可变引用
    let iter_mut = vec.iter_mut();  // 可变引用  
    let into_iter = vec.into_iter(); // 获取所有权
    
    println!("Immutable iterator: {:?}", iter);
    
    // 从其他集合创建迭代器
    let array = [1, 2, 3, 4, 5];
    let array_iter = array.iter();
    
    let hashmap = std::collections::HashMap::from([(1, "one"), (2, "two")]);
    let hashmap_iter = hashmap.iter();
    
    // 范围迭代器
    let range_iter = (1..=5).into_iter();
    
    // 无限迭代器
    let ones = std::iter::repeat(1);
    let cycle = vec![1, 2, 3].into_iter().cycle();
}

基本的迭代器使用

fn basic_iterator_usage() {
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    // 手动使用迭代器
    let mut iter = numbers.iter();
    while let Some(number) = iter.next() {
        print!("{} ", number);
    }
    println!();
    
    // for循环（语法糖）
    for number in &numbers {
        print!("{} ", number);
    }
    println!();
    
    // 消费迭代器的方法
    let sum: i32 = numbers.iter().sum();
    let product: i32 = numbers.iter().product();
    let count = numbers.iter().count();
    
    println!("Sum: {}, Product: {}, Count: {}", sum, product, count);
    
    // 收集到不同的集合类型
    let doubled: Vec<i32> = numbers.iter().map(|&x| x * 2).collect();
    let set: std::collections::HashSet<_> = numbers.iter().collect();
    let string: String = numbers.iter().map(|x| x.to_string()).collect();
    
    println!("Doubled: {:?}", doubled);
    println!("Set: {:?}", set);
    println!("String: {}", string);
}

迭代器适配器

迭代器适配器可以将一个迭代器转换为另一个迭代器，这是函数式编程的核心概念。

转换适配器

fn transformation_adapters() {
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    // map - 转换每个元素
    let squared: Vec<i32> = numbers.iter().map(|&x| x * x).collect();
    println!("Squared: {:?}", squared);
    
    // filter - 过滤元素
    let evens: Vec<&i32> = numbers.iter().filter(|&&x| x % 2 == 0).collect();
    println!("Evens: {:?}", evens);
    
    // filter_map - 过滤和转换组合
    let maybe_numbers = vec![Some(1), None, Some(3), None, Some(5)];
    let values: Vec<i32> = maybe_numbers.into_iter().filter_map(|x| x).collect();
    println!("Filtered values: {:?}", values);
    
    // flat_map - 展平嵌套结构
    let matrix = vec![vec![1, 2], vec![3, 4], vec![5, 6]];
    let flattened: Vec<i32> = matrix.into_iter().flat_map(|row| row).collect();
    println!("Flattened: {:?}", flattened);
    
    // scan - 带有状态的转换
    let running_total: Vec<i32> = numbers.iter()
        .scan(0, |state, &x| {
            *state += x;
            Some(*state)
        })
        .collect();
    println!("Running total: {:?}", running_total);
}

组合适配器

fn combination_adapters() {
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    // take - 取前n个元素
    let first_three: Vec<&i32> = numbers.iter().take(3).collect();
    println!("First three: {:?}", first_three);
    
    // skip - 跳过前n个元素
    let after_three: Vec<&i32> = numbers.iter().skip(3).collect();
    println!("After three: {:?}", after_three);
    
    // take_while - 条件取元素
    let until_five: Vec<&i32> = numbers.iter().take_while(|&&x| x < 5).collect();
    println!("Until five: {:?}", until_five);
    
    // skip_while - 条件跳元素
    let after_five: Vec<&i32> = numbers.iter().skip_while(|&&x| x <= 5).collect();
    println!("After five: {:?}", after_five);
    
    // chain - 连接迭代器
    let part1 = vec![1, 2, 3];
    let part2 = vec![4, 5, 6];
    let chained: Vec<i32> = part1.into_iter().chain(part2).collect();
    println!("Chained: {:?}", chained);
    
    // zip - 并行迭代
    let names = vec!["Alice", "Bob", "Charlie"];
    let ages = vec![25, 30, 35];
    let zipped: Vec<(&str, i32)> = names.into_iter().zip(ages).collect();
    println!("Zipped: {:?}", zipped);
    
    // enumerate - 带索引的迭代
    let enumerated: Vec<(usize, &i32)> = numbers.iter().enumerate().collect();
    println!("Enumerated: {:?}", enumerated);
}

消费迭代器

消费适配器会消耗迭代器并产生最终结果。

fn consuming_adapters() {
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    // sum 和 product
    let total: i32 = numbers.iter().sum();
    let product: i32 = numbers.iter().product();
    println!("Sum: {}, Product: {}", total, product);
    
    // count
    let count = numbers.iter().count();
    println!("Count: {}", count);
    
    // min 和 max
    let min = numbers.iter().min();
    let max = numbers.iter().max();
    println!("Min: {:?}, Max: {:?}", min, max);
    
    // find 和 position
    let found = numbers.iter().find(|&&x| x > 5);
    let position = numbers.iter().position(|&x| x == 7);
    println!("First > 5: {:?}, Position of 7: {:?}", found, position);
    
    // all 和 any
    let all_even = numbers.iter().all(|&x| x % 2 == 0);
    let any_even = numbers.iter().any(|&x| x % 2 == 0);
    println!("All even: {}, Any even: {}", all_even, any_even);
    
    // fold - 通用累积操作
    let sum_fold = numbers.iter().fold(0, |acc, &x| acc + x);
    let product_fold = numbers.iter().fold(1, |acc, &x| acc * x);
    println!("Fold sum: {}, Fold product: {}", sum_fold, product_fold);
    
    // reduce - 类似fold但没有初始值
    let max_reduce = numbers.iter().reduce(|acc, &x| if x > acc { x } else { acc });
    println!("Reduce max: {:?}", max_reduce);
    
    // collect到不同类型的集合
    let doubled_vec: Vec<i32> = numbers.iter().map(|&x| x * 2).collect();
    let set: std::collections::HashSet<_> = numbers.iter().collect();
    let string: String = numbers.iter().map(|x| x.to_string()).collect::<String>();
    
    println!("Doubled vec: {:?}", doubled_vec);
    println!("Set: {:?}", set);
    println!("String: {}", string);
}

自定义迭代器

我们可以为自己的类型实现Iterator trait。

struct Fibonacci {
    current: u64,
    next: u64,
}

impl Fibonacci {
    fn new() -> Self {
        Fibonacci {
            current: 0,
            next: 1,
        }
    }
}

impl Iterator for Fibonacci {
    type Item = u64;
    
    fn next(&mut self) -> Option<Self::Item> {
        let new_next = self.current.checked_add(self.next)?;
        
        let result = self.current;
        self.current = self.next;
        self.next = new_next;
        
        Some(result)
    }
}

struct RangeStep {
    start: i32,
    end: i32,
    step: i32,
}

impl RangeStep {
    fn new(start: i32, end: i32, step: i32) -> Self {
        RangeStep { start, end, step }
    }
}

impl Iterator for RangeStep {
    type Item = i32;
    
    fn next(&mut self) -> Option<Self::Item> {
        if self.start >= self.end {
            return None;
        }
        
        let current = self.start;
        self.start += self.step;
        Some(current)
    }
}

fn custom_iterators_demo() {
    println!("Fibonacci sequence:");
    let fib = Fibonacci::new();
    for (i, num) in fib.take(10).enumerate() {
        println!("F{} = {}", i, num);
    }
    
    println!("\nRange with step:");
    let range_step = RangeStep::new(0, 20, 3);
    for num in range_step {
        print!("{} ", num);
    }
    println!();
    
    // 使用迭代器适配器处理自定义迭代器
    let even_fib: Vec<u64> = Fibonacci::new()
        .take(15)
        .filter(|&x| x % 2 == 0)
        .collect();
    println!("Even Fibonacci numbers: {:?}", even_fib);
}

13.3 函数式编程模式

不可变性与纯函数

函数式编程强调不可变数据和纯函数（没有副作用的函数）。

// 纯函数示例
fn pure_functions() {
    // 纯函数：相同的输入总是产生相同的输出，没有副作用
    fn add(a: i32, b: i32) -> i32 {
        a + b
    }
    
    fn square(x: i32) -> i32 {
        x * x
    }
    
    fn factorial(n: u64) -> u64 {
        if n == 0 { 1 } else { n * factorial(n - 1) }
    }
    
    // 使用纯函数构建复杂操作
    let result = square(add(3, 4));
    println!("(3 + 4)^2 = {}", result);
    
    println!("5! = {}", factorial(5));
    
    // 函数组合
    fn compose<A, B, C, F, G>(f: F, g: G) -> impl Fn(A) -> C
    where
        F: Fn(A) -> B,
        G: Fn(B) -> C,
    {
        move |x| g(f(x))
    }
    
    let add_then_square = compose(add, square);
    println!("add_then_square(2, 3) = {}", add_then_square(2, 3));
}

// 不可变数据结构
fn immutable_data_structures() {
    // 使用不可变操作
    let mut numbers = vec![1, 2, 3];
    
    // 函数式风格：创建新集合而不是修改原有集合
    let doubled: Vec<i32> = numbers.iter().map(|&x| x * 2).collect();
    println!("Original: {:?}", numbers);
    println!("Doubled: {:?}", doubled);
    
    // 过滤并创建新集合
    let evens: Vec<i32> = numbers.iter().filter(|&&x| x % 2 == 0).cloned().collect();
    println!("Evens: {:?}", evens);
    
    // 排序（创建新排序的向量）
    let sorted = {
        let mut temp = numbers.clone();
        temp.sort();
        temp
    };
    println!("Sorted: {:?}", sorted);
    println!("Original still intact: {:?}", numbers);
}

高阶函数

高阶函数是以函数作为参数或返回函数的函数。

fn higher_order_functions() {
    // 接受函数作为参数的函数
    fn apply_twice<F>(f: F, x: i32) -> i32 
    where 
        F: Fn(i32) -> i32,
    {
        f(f(x))
    }
    
    let double = |x| x * 2;
    let square = |x| x * x;
    
    println!("Double twice of 3: {}", apply_twice(double, 3));
    println!("Square twice of 2: {}", apply_twice(square, 2));
    
    // 返回函数的函数（函数工厂）
    fn make_multiplier(factor: i32) -> impl Fn(i32) -> i32 {
        move |x| x * factor
    }
    
    let triple = make_multiplier(3);
    let quintuple = make_multiplier(5);
    
    println!("Triple of 4: {}", triple(4));
    println!("Quintuple of 4: {}", quintuple(4));
    
    // 更复杂的高阶函数
    fn filter_map<F, G, T, U>(predicate: F, mapper: G, items: &[T]) -> Vec<U>
    where
        F: Fn(&T) -> bool,
        G: Fn(&T) -> U,
    {
        items.iter()
            .filter(|item| predicate(item))
            .map(|item| mapper(item))
            .collect()
    }
    
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    let result = filter_map(
        |&x| x % 2 == 0,      // 谓词：偶数
        |&x| x.to_string(),   // 映射器：转换为字符串
        &numbers
    );
    
    println!("Filtered and mapped: {:?}", result);
}

声明式编程模式

使用声明式风格描述要做什么，而不是如何做。

fn declarative_programming() {
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    // 命令式风格（描述如何做）
    let mut command_result = Vec::new();
    for i in 0..numbers.len() {
        if numbers[i] % 2 == 0 {
            command_result.push(numbers[i] * 2);
        }
    }
    println!("Command style: {:?}", command_result);
    
    // 声明式风格（描述要做什么）
    let declarative_result: Vec<i32> = numbers.iter()
        .filter(|&&x| x % 2 == 0)
        .map(|&x| x * 2)
        .collect();
    println!("Declarative style: {:?}", declarative_result);
    
    // 更复杂的声明式操作
    let complex_result: Vec<String> = numbers.iter()
        .filter(|&&x| x > 3 && x < 8)    // 4, 5, 6, 7
        .map(|&x| x * 3)                 // 12, 15, 18, 21
        .filter(|&x| x % 2 == 0)         // 12, 18
        .map(|x| format!("Value: {}", x)) // "Value: 12", "Value: 18"
        .collect();
    
    println!("Complex pipeline: {:?}", complex_result);
    
    // 数据处理管道
    struct DataPoint {
        value: f64,
        category: String,
    }
    
    let data = vec![
        DataPoint { value: 1.5, category: "A".to_string() },
        DataPoint { value: 2.5, category: "B".to_string() },
        DataPoint { value: 3.5, category: "A".to_string() },
        DataPoint { value: 4.5, category: "C".to_string() },
        DataPoint { value: 5.5, category: "B".to_string() },
    ];
    
    let processed: Vec<String> = data.into_iter()
        .filter(|point| point.value > 2.0)
        .map(|point| (point.category, point.value))
        .fold(std::collections::HashMap::new(), |mut acc, (category, value)| {
            *acc.entry(category).or_insert(0.0) += value;
            acc
        })
        .into_iter()
        .map(|(category, total)| format!("{}: {:.1}", category, total))
        .collect();
    
    println!("Processed data: {:?}", processed);
}

Monad模式与Option/Result组合

Rust的Option和Result类型类似于函数式编程中的Monad，支持组合操作。

fn monadic_patterns() {
    // Option的组合操作
    fn parse_number(s: &str) -> Option<i32> {
        s.parse().ok()
    }
    
    fn double_number(n: i32) -> Option<i32> {
        Some(n * 2)
    }
    
    // 使用and_then进行链式操作
    let result1 = parse_number("42").and_then(double_number);
    let result2 = parse_number("hello").and_then(double_number);
    
    println!("Result1: {:?}", result1); // Some(84)
    println!("Result2: {:?}", result2); // None
    
    // 使用map进行转换
    let result3 = parse_number("21").map(|n| n * 3);
    println!("Result3: {:?}", result3); // Some(63)
    
    // 使用or_else提供默认值
    let result4 = parse_number("invalid").or_else(|| Some(0));
    println!("Result4: {:?}", result4); // Some(0)
    
    // Result的组合操作
    fn divide(a: f64, b: f64) -> Result<f64, String> {
        if b == 0.0 {
            Err("Division by zero".to_string())
        } else {
            Ok(a / b)
        }
    }
    
    fn validate_positive(x: f64) -> Result<f64, String> {
        if x >= 0.0 {
            Ok(x)
        } else {
            Err("Negative value".to_string())
        }
    }
    
    // 组合多个可能失败的操作
    let calculation = divide(10.0, 2.0)
        .and_then(validate_positive)
        .map(|x| x * 100.0);
    
    println!("Calculation: {:?}", calculation); // Ok(500.0)
    
    // 使用?运算符的错误传播
    fn complex_calculation(a: f64, b: f64) -> Result<f64, String> {
        let result1 = divide(a, b)?;
        let result2 = validate_positive(result1)?;
        Ok(result2 * 100.0)
    }
    
    println!("Complex success: {:?}", complex_calculation(10.0, 2.0));
    println!("Complex error: {:?}", complex_calculation(10.0, 0.0));
    
    // 使用组合器处理多个Result
    let results = vec![
        complex_calculation(10.0, 2.0),
        complex_calculation(20.0, 4.0),
        complex_calculation(30.0, 0.0), // 这个会失败
        complex_calculation(40.0, 5.0),
    ];
    
    // 收集所有成功的值
    let successes: Vec<f64> = results.iter()
        .filter_map(Result::ok)
        .collect();
    
    println!("Successes: {:?}", successes);
    
    // 分别处理成功和失败
    let (oks, errs): (Vec<_>, Vec<_>) = results.into_iter()
        .partition(Result::is_ok);
    
    let oks: Vec<f64> = oks.into_iter().map(Result::unwrap).collect();
    let errs: Vec<String> = errs.into_iter().map(Result::unwrap_err).collect();
    
    println!("Oks: {:?}", oks);
    println!("Errors: {:?}", errs);
}

13.4 性能对比与选择

闭包性能分析

闭包在Rust中是零成本抽象，但不同的捕获方式会影响性能。

#[cfg(test)]
mod closure_performance {
    use super::*;
    use std::time::Instant;
    
    // 测试不同闭包类型的性能
    fn benchmark_closures() {
        let data: Vec<i32> = (0..1_000_000).collect();
        
        // 测试Fn闭包（不可变借用）
        let start = Instant::now();
        let sum_fn: i32 = data.iter().map(|&x| x * 2).sum();
        let duration_fn = start.elapsed();
        
        // 测试FnMut闭包（可变借用）
        let start = Instant::now();
        let mut accumulator = 0;
        data.iter().for_each(|&x| accumulator += x * 2);
        let duration_fn_mut = start.elapsed();
        
        // 测试FnOnce闭包（移动语义）
        let start = Instant::now();
        let sum_fn_once: i32 = data.into_iter().map(|x| x * 2).sum();
        let duration_fn_once = start.elapsed();
        
        println!("Fn closure time: {:?}", duration_fn);
        println!("FnMut closure time: {:?}", duration_fn_mut);
        println!("FnOnce closure time: {:?}", duration_fn_once);
        println!("All sums should be equal: {} = {} = {}", sum_fn, accumulator, sum_fn_once);
    }
    
    // 测试闭包内联优化
    fn test_inline_optimization() {
        let numbers = vec![1, 2, 3, 4, 5];
        
        // 简单闭包通常会被内联
        let simple_closure = |x: i32| x * 2;
        
        // 复杂闭包可能不会完全内联
        let complex_closure = |x: i32| {
            let intermediate = x * 3;
            intermediate + 10 - 5 * 2
        };
        
        let simple_result: Vec<i32> = numbers.iter().map(|&x| simple_closure(x)).collect();
        let complex_result: Vec<i32> = numbers.iter().map(|&x| complex_closure(x)).collect();
        
        println!("Simple: {:?}", simple_result);
        println!("Complex: {:?}", complex_result);
    }
}

fn closure_performance_demo() {
    closure_performance::benchmark_closures();
    closure_performance::test_inline_optimization();
}

迭代器性能分析

迭代器在Rust中也是零成本抽象，通常与手写循环性能相当甚至更好。

#[cfg(test)]
mod iterator_performance {
    use super::*;
    use std::time::Instant;
    
    fn benchmark_iterators_vs_loops() {
        let data: Vec<i32> = (0..1_000_000).collect();
        
        // 测试迭代器性能
        let start = Instant::now();
        let iter_sum: i32 = data.iter().map(|&x| x * 2).sum();
        let iter_duration = start.elapsed();
        
        // 测试手写循环性能
        let start = Instant::now();
        let mut loop_sum = 0;
        for &x in &data {
            loop_sum += x * 2;
        }
        let loop_duration = start.elapsed();
        
        println!("Iterator time: {:?}", iter_duration);
        println!("Loop time: {:?}", loop_duration);
        println!("Sums equal: {}", iter_sum == loop_sum);
        
        // 测试复杂操作的性能
        let start = Instant::now();
        let iter_complex: Vec<i32> = data.iter()
            .filter(|&&x| x % 2 == 0)
            .map(|&x| x * 3)
            .filter(|&x| x > 1_000_000)
            .collect();
        let iter_complex_duration = start.elapsed();
        
        let start = Instant::now();
        let mut loop_complex = Vec::new();
        for &x in &data {
            if x % 2 == 0 {
                let temp = x * 3;
                if temp > 1_000_000 {
                    loop_complex.push(temp);
                }
            }
        }
        let loop_complex_duration = start.elapsed();
        
        println!("Complex iterator time: {:?}", iter_complex_duration);
        println!("Complex loop time: {:?}", loop_complex_duration);
        println!("Complex results equal: {}", iter_complex == loop_complex);
    }
    
    // 测试惰性求值的性能优势
    fn test_lazy_evaluation() {
        let data: Vec<i32> = (0..100_000).collect();
        
        // 急切求值（立即计算所有值）
        let start = Instant::now();
        let eager_result: Vec<i32> = data.iter()
            .map(|&x| {
                // 模拟昂贵计算
                std::thread::sleep(std::time::Duration::from_nanos(1));
                x * 2
            })
            .take(10)
            .collect();
        let eager_duration = start.elapsed();
        
        // 惰性求值（只在需要时计算）
        let start = Instant::now();
        let lazy_result: Vec<i32> = data.iter()
            .map(|&x| {
                std::thread::sleep(std::time::Duration::from_nanos(1));
                x * 2
            })
            .take(10)
            .collect();
        let lazy_duration = start.elapsed();
        
        println!("Eager evaluation time: {:?}", eager_duration);
        println!("Lazy evaluation time: {:?}", lazy_duration);
        println!("Results equal: {}", eager_result == lazy_result);
    }
}

fn iterator_performance_demo() {
    iterator_performance::benchmark_iterators_vs_loops();
    iterator_performance::test_lazy_evaluation();
}

选择指南：何时使用函数式风格

fn style_selection_guide() {
    println!("=== 函数式 vs 命令式选择指南 ===");
    
    println!("\n使用函数式风格当：");
    println!("1. 处理数据转换管道时");
    println!("2. 需要组合多个操作时");
    println!("3. 强调代码的可读性和声明性时");
    println!("4. 处理可选值或错误处理时（Option/Result组合）");
    println!("5. 需要惰性求值时");
    
    println!("\n使用命令式风格当：");
    println!("1. 需要细粒度控制流程时");
    println!("2. 性能极度关键且手写循环可能更快时");
    println!("3. 有复杂的状态更新时");
    println!("4. 代码逻辑难以用函数式表达时");
    
    println!("\n实际示例对比：");
    
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    // 命令式风格
    let mut command_result = Vec::new();
    for i in 0..numbers.len() {
        if numbers[i] % 2 == 0 {
            command_result.push(numbers[i] * 2);
        }
    }
    
    // 函数式风格
    let functional_result: Vec<i32> = numbers.iter()
        .filter(|&&x| x % 2 == 0)
        .map(|&x| x * 2)
        .collect();
    
    println!("命令式结果: {:?}", command_result);
    println!("函数式结果: {:?}", functional_result);
    println!("结果相等: {}", command_result == functional_result);
    
    // 复杂场景的对比
    struct Person {
        name: String,
        age: u32,
        active: bool,
    }
    
    let people = vec![
        Person { name: "Alice".to_string(), age: 25, active: true },
        Person { name: "Bob".to_string(), age: 30, active: false },
        Person { name: "Charlie".to_string(), age: 35, active: true },
        Person { name: "Diana".to_string(), age: 28, active: true },
    ];
    
    // 命令式：找出活跃用户的平均年龄
    let mut total_age = 0;
    let mut count = 0;
    for person in &people {
        if person.active {
            total_age += person.age;
            count += 1;
        }
    }
    let command_avg = if count > 0 { total_age / count } else { 0 };
    
    // 函数式：同样的逻辑
    let functional_avg = people.iter()
        .filter(|p| p.active)
        .map(|p| p.age)
        .fold((0, 0), |(sum, count), age| (sum + age, count + 1));
    let functional_avg = if functional_avg.1 > 0 { 
        functional_avg.0 / functional_avg.1 
    } else { 
        0 
    };
    
    // 更地道的函数式写法
    let functional_avg_better: Option<u32> = people.iter()
        .filter(|p| p.active)
        .map(|p| p.age)
        .fold(None, |acc, age| {
            Some(acc.map_or((age, 1), |(sum, count)| (sum + age, count + 1)))
        })
        .map(|(sum, count)| sum / count);
    
    println!("命令式平均年龄: {}", command_avg);
    println!("函数式平均年龄: {}", functional_avg);
    println!("更好的函数式平均年龄: {:?}", functional_avg_better);
}

实战：函数式数据处理系统

让我们构建一个完整的数据处理系统来展示函数式编程的实际应用：

use std::collections::HashMap;

#[derive(Debug, Clone)]
struct DataPoint {
    timestamp: u64,
    value: f64,
    category: String,
    tags: Vec<String>,
}

struct DataProcessor;

impl DataProcessor {
    // 纯函数：数据转换
    fn normalize_value(value: f64, min: f64, max: f64) -> f64 {
        if max == min {
            0.0
        } else {
            (value - min) / (max - min)
        }
    }
    
    // 高阶函数：创建数据处理管道
    fn create_processing_pipeline<F>(filter: F) -> impl Fn(Vec<DataPoint>) -> Vec<DataPoint>
    where
        F: Fn(&DataPoint) -> bool + 'static,
    {
        move |data| {
            data.into_iter()
                .filter(|point| filter(point))
                .collect()
        }
    }
    
    // 复杂的数据分析
    fn analyze_data(data: &[DataPoint]) -> HashMap<String, f64> {
        data.iter()
            .fold(HashMap::new(), |mut acc, point| {
                let entry = acc.entry(point.category.clone()).or_insert(0.0);
                *entry += point.value;
                acc
            })
    }
    
    // 使用Option组合处理可能缺失的数据
    fn process_optional_data(data: Vec<Option<DataPoint>>) -> Vec<DataPoint> {
        data.into_iter()
            .filter_map(|point| point)
            .filter(|point| point.value >= 0.0)
            .collect()
    }
    
    // 声明式数据查询
    fn query_data<F>(data: &[DataPoint], condition: F) -> Vec<&DataPoint>
    where
        F: Fn(&&DataPoint) -> bool,
    {
        data.iter()
            .filter(condition)
            .collect()
    }
    
    // 数据分组和聚合
    fn group_and_aggregate(data: &[DataPoint]) -> HashMap<String, (f64, usize)> {
        data.iter()
            .fold(HashMap::new(), |mut acc, point| {
                let entry = acc.entry(point.category.clone())
                    .or_insert((0.0, 0));
                entry.0 += point.value;
                entry.1 += 1;
                acc
            })
    }
}

// 流式数据处理
struct StreamProcessor<F, G>
where
    F: Fn(&DataPoint) -> bool,
    G: Fn(DataPoint) -> DataPoint,
{
    filter: F,
    mapper: G,
    buffer: Vec<DataPoint>,
}

impl<F, G> StreamProcessor<F, G>
where
    F: Fn(&DataPoint) -> bool,
    G: Fn(DataPoint) -> DataPoint,
{
    fn new(filter: F, mapper: G) -> Self {
        StreamProcessor {
            filter,
            mapper,
            buffer: Vec::new(),
        }
    }
    
    fn process(&mut self, data_point: DataPoint) -> Option<DataPoint> {
        if (self.filter)(&data_point) {
            let processed = (self.mapper)(data_point);
            self.buffer.push(processed.clone());
            Some(processed)
        } else {
            None
        }
    }
    
    fn get_statistics(&self) -> HashMap<String, f64> {
        DataProcessor::analyze_data(&self.buffer)
    }
}

fn data_processing_demo() {
    println!("=== 函数式数据处理演示 ===");
    
    // 创建测试数据
    let data = vec![
        DataPoint {
            timestamp: 1000,
            value: 25.5,
            category: "temperature".to_string(),
            tags: vec!["sensor1".to_string(), "room1".to_string()],
        },
        DataPoint {
            timestamp: 1001,
            value: 26.0,
            category: "temperature".to_string(),
            tags: vec!["sensor2".to_string(), "room2".to_string()],
        },
        DataPoint {
            timestamp: 1002,
            value: -1.0, // 无效数据
            category: "temperature".to_string(),
            tags: vec!["sensor3".to_string(), "room1".to_string()],
        },
        DataPoint {
            timestamp: 1003,
            value: 65.0,
            category: "humidity".to_string(),
            tags: vec!["sensor1".to_string(), "room1".to_string()],
        },
        DataPoint {
            timestamp: 1004,
            value: 70.0,
            category: "humidity".to_string(),
            tags: vec!["sensor2".to_string(), "room2".to_string()],
        },
    ];
    
    // 使用数据处理管道
    let temperature_pipeline = DataProcessor::create_processing_pipeline(|point| {
        point.category == "temperature" && point.value >= 0.0
    });
    
    let filtered_data = temperature_pipeline(data.clone());
    println!("过滤后的温度数据: {}", filtered_data.len());
    
    // 数据分析
    let analysis = DataProcessor::analyze_data(&data);
    println!("数据分析结果: {:?}", analysis);
    
    // 数据分组和聚合
    let grouped = DataProcessor::group_and_aggregate(&data);
    println!("分组聚合结果: {:?}", grouped);
    
    // 声明式查询
    let room1_data = DataProcessor::query_data(&data, |point| {
        point.tags.contains(&"room1".to_string())
    });
    println!("Room1 数据点数量: {}", room1_data.len());
    
    // 流式处理演示
    let mut stream_processor = StreamProcessor::new(
        |point| point.value >= 0.0, // 过滤器：只处理有效数据
        |mut point| {               // 映射器：转换数据
            point.value = DataProcessor::normalize_value(point.value, 0.0, 100.0);
            point
        },
    );
    
    for point in data {
        if let Some(processed) = stream_processor.process(point) {
            println!("处理后的数据点: {:?}", processed);
        }
    }
    
    let stats = stream_processor.get_statistics();
    println!("流处理统计: {:?}", stats);
}

fn main() {
    closure_basics();
    environment_capture();
    closure_traits_demo();
    callback_demo();
    configurable_behavior_demo();
    closure_lifetimes();
    
    iterator_creation();
    basic_iterator_usage();
    transformation_adapters();
    combination_adapters();
    consuming_adapters();
    custom_iterators_demo();
    
    pure_functions();
    immutable_data_structures();
    higher_order_functions();
    declarative_programming();
    monadic_patterns();
    
    closure_performance_demo();
    iterator_performance_demo();
    style_selection_guide();
    data_processing_demo();
}

总结

Rust的函数式编程特性提供了强大的工具来编写简洁、安全且高效的代码。通过本章的学习，我们掌握了：

1. 闭包：能够捕获环境的匿名函数，支持不同的捕获方式（Fn、FnMut、FnOnce）
2. 迭代器：处理元素序列的强大工具，支持转换、过滤、组合等操作
3. 函数式模式：包括不可变性、纯函数、高阶函数和声明式编程
4. 性能分析：理解函数式特性的性能特征和适用场景

函数式编程风格与Rust的所有权系统完美结合，使得我们能够编写出既表达力强又内存安全的代码。在实际开发中，应该根据具体场景选择合适的编程风格，充分利用Rust提供的各种工具。

在下一章中，我们将探讨Rust的智能指针，了解如何通过Box、Rc、Arc等类型来管理堆内存和实现更复杂的所有权模式。