Rust函数式编程扩展库tryfn使用指南

tryfn是一个为Rust设计的函数式编程扩展库，提供了高阶函数组合、延迟求值等函数式编程工具，让Rust开发者能够更方便地使用函数式编程范式。

主要特性

1. 高阶函数组合
2. 延迟求值(Lazy Evaluation)
3. 函数柯里化(Currying)
4. 函数管道(Pipelining)
5. 错误处理增强

安装

在Cargo.toml中添加依赖：

[dependencies]
tryfn = "0.2"

基本用法

1. 函数组合

use tryfn::compose;

fn add_one(x: i32) -> i32 { x + 1 }
fn square(x: i32) -> i32 { x * x }

let composed = compose!(square, add_one);
println!("{}", composed(2)); // 输出: 9 (先执行add_one(2)=3, 然后square(3)=9)

2. 延迟求值

use tryfn::lazy::Lazy;

let expensive_computation = Lazy::new(|| {
    println!("Performing expensive computation...");
    42 * 42
});

// 计算尚未执行
println!("Lazy value created");
// 第一次访问时执行计算
println!("{}", *expensive_computation); // 输出: Performing expensive computation... 1764
// 后续访问使用缓存值
println!("{}", *expensive_computation); // 只输出: 1764

3. 函数柯里化

use tryfn::curry;

#[curry]
fn add(x: i32, y: i32) -> i32 {
    x + y
}

let add5 = add(5);
println!("{}", add5(3)); // 输出: 8

4. 函数管道

use tryfn::pipe;

fn double(x: i32) -> i32 { x * 2 }
fn increment(x: i32) -> i32 { x + 1 }

let result = pipe!(5 => double => increment);
println!("{}", result); // 输出: 11 (5*2=10, 10+1=11)

5. 错误处理增强

use tryfn::ResultExt;

fn might_fail(x: i32) -> Result<i32, String> {
    if x > 0 { Ok(x * 2) } else { Err("Negative value".to_string()) }
}

let result = might_fail(5)
    .and_then(|x| Ok(x + 3))
    .map_err(|e| format!("Error: {}", e));

println!("{:?}", result); // 输出: Ok(13)

高级用法

惰性集合操作

use tryfn::lazy::LazySeq;

let numbers = vec![1, 2, 3, 4, 5];
let lazy_result = LazySeq::from(numbers)
    .map(|x| x * 2)
    .filter(|&x| x > 5)
    .take(2);

// 尚未执行任何计算
println!("Lazy sequence created");
// 收集结果时执行计算
let result: Vec<_> = lazy_result.collect();
println!("{:?}", result); // 输出: [6, 8]

函数记忆化(Memoization)

use tryfn::memoize;

#[memoize]
fn fibonacci(n: u32) -> u32 {
    match n {
        0 => 0,
        1 => 1,
        _ => fibonacci(n - 1) + fibonacci(n - 2),
    }
}

// 第一次计算会执行实际计算
println!("{}", fibonacci(10)); // 计算并缓存结果
// 后续调用使用缓存值
println!("{}", fibonacci(10)); // 直接返回缓存结果

性能考虑

1. 惰性求值可以避免不必要的计算，但会带来少量内存开销
2. 记忆化会提高重复调用的性能，但会增加内存使用
3. 函数组合和柯里化会引入少量运行时开销

tryfn适合在需要函数式编程风格的场景使用，但在性能关键的代码路径中应谨慎评估开销。

总结

tryfn为Rust带来了更丰富的函数式编程能力，通过高阶函数、惰性求值等特性，可以让代码更简洁、表达力更强。特别是在数据处理、异步编程等场景下，能显著提升代码的可读性和可维护性。

完整示例代码

下面是一个整合了tryfn主要特性的完整示例：

use tryfn::{compose, curry, pipe, memoize, lazy::{Lazy, LazySeq}, ResultExt};

fn main() {
    // 1. 函数组合示例
    fn add_one(x: i32) -> i32 { x + 1 }
    fn square(x: i32) -> i32 { x * x }
    let composed = compose!(square, add_one);
    println!("组合函数结果: {}", composed(2)); // 9

    // 2. 延迟求值示例
    let lazy_val = Lazy::new(|| {
        println!("计算延迟值...");
        42
    });
    println!("延迟值已创建");
    println!("延迟值: {}", *lazy_val); // 第一次访问时计算
    println!("延迟值: {}", *lazy_val); // 使用缓存值

    // 3. 柯里化示例
    #[curry]
    fn multiply(x: i32, y: i32) -> i32 { x * y }
    let double = multiply(2);
    println!("柯里化结果: {}", double(5)); // 10

    // 4. 管道示例
    fn to_string(x: i32) -> String { x.to_string() }
    fn add_exclamation(s: String) -> String { s + "!" }
    let piped = pipe!(42 => to_string => add_exclamation);
    println!("管道结果: {}", piped); // "42!"

    // 5. 错误处理增强示例
    fn parse_number(s: &str) -> Result<i32, String> {
        s.parse().map_err(|_| "解析失败".to_string())
    }
    let result = parse_number("123")
        .and_then(|x| Ok(x * 2))
        .map_err(|e| format!("错误: {}", e));
    println!("增强错误处理: {:?}", result); // Ok(246)

    // 6. 惰性集合操作示例
    let nums = vec![1, 2, 3, 4, 5];
    let lazy_nums = LazySeq::from(nums)
        .map(|x| x * 3)
        .filter(|&x| x > 6);
    println!("惰性集合: {:?}", lazy_nums.collect::<Vec<_>>()); // [9, 12, 15]

    // 7. 记忆化示例
    #[memoize]
    fn factorial(n: u32) -> u32 {
        if n <= 1 { 1 } else { n * factorial(n - 1) }
    }
    println!("记忆化阶乘(5): {}", factorial(5)); // 120 (计算并缓存)
    println!("记忆化阶乘(5): {}", factorial(5)); // 120 (从缓存读取)
}