第13章 函数式语言特性

第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>
whereF: Fn(&str),
{callback: F,
}impl<F> EventHandler<F>
whereF: 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>
whereF: Fn(i32) -> i32,
{processor: F,
}impl<F> DataProcessor<F>
whereF: 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> + 'awhereF: 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 和 productlet total: i32 = numbers.iter().sum();let product: i32 = numbers.iter().product();println!("Sum: {}, Product: {}", total, product);// countlet count = numbers.iter().count();println!("Count: {}", count);// min 和 maxlet min = numbers.iter().min();let max = numbers.iter().max();println!("Min: {:?}, Max: {:?}", min, max);// find 和 positionlet found = numbers.iter().find(|&&x| x > 5);let position = numbers.iter().position(|&x| x == 7);println!("First > 5: {:?}, Position of 7: {:?}", found, position);// all 和 anylet 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) -> CwhereF: 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>whereF: 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));// 使用组合器处理多个Resultlet 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>whereF: 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>whereF: 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>
whereF: Fn(&DataPoint) -> bool,G: Fn(DataPoint) -> DataPoint,
{filter: F,mapper: G,buffer: Vec<DataPoint>,
}impl<F, G> StreamProcessor<F, G>
whereF: 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等类型来管理堆内存和实现更复杂的所有权模式。