Rust函数包装库func_wrap使用指南

简介

func_wrap是一个Rust库，专门用于函数组合和代码复用。它提供了一种简洁的方式来包装、组合和重用函数，特别适合函数式编程风格和需要高度复用代码的场景。

主要特性

• 函数包装：将普通函数包装成可组合的形式
• 函数组合：支持管道式函数组合
• 柯里化：支持函数柯里化
• 参数绑定：支持部分参数绑定
• 惰性求值：支持创建惰性求值的函数链

安装

在Cargo.toml中添加依赖：

[dependencies]
func_wrap = "0.3"

基本用法

1. 简单包装

use func_wrap::wrap;

fn add(a: i32, b: i32) -> i32 {
    a + b
}

let wrapped_add = wrap!(add);
println!("{}", wrapped_add(2, 3)); // 输出: 5

2. 函数组合

use func_wrap::{wrap, compose};

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

let composed = compose!(wrap!(double), wrap!(add_one));
println!("{}", composed(5)); // 输出: 11 (先执行add_one，再double)

3. 管道式调用

use func_wrap::{wrap, pipe};

fn square(x: i32) -> i32 { x * x }
fn subtract_five(x: i32) -> i32 { x - 5 }

let pipeline = pipe!(wrap!(square), wrap!(subtract_five));
println!("{}", pipeline(4)); // 输出: 11 (16 - 5)

4. 柯里化

use func_wrap::curry;

fn add_three(a: i32, b: i32, c: i32) -> i32 {
    a + b + c
}

let curried = curry!(add_three);
let add_two_numbers = curried(5); // 绑定第一个参数
let result = add_two_numbers(3)(2); // 依次绑定剩余参数
println!("{}", result); // 输出: 10

5. 部分应用

use func_wrap::partial;

fn greet(greeting: &str, name: &str) -> String {
    format!("{}, {}!", greeting, name)
}

let say_hello = partial!(greet, "Hello");
println!("{}", say_hello("Rust")); // 输出: "Hello, Rust!"

高级用法

惰性求值链

use func_wrap::{wrap, lazy_chain};

fn parse(s: &str) -> i32 { s.parse().unwrap() }
fn negate(x: i32) -> i32 { -x }
fn to_string(x: i32) -> String { x.to_string() }

let lazy_eval = lazy_chain!(
    wrap!(parse),
    wrap!(negate),
    wrap!(to_string)
);

let result = lazy_eval("42").force(); // 实际执行计算
println!("{}", result); // 输出: "-42"

错误处理组合

use func_wrap::{wrap, try_compose};
use std::num::ParseIntError;

fn parse(s: &str) -> Result<i32, ParseIntError> {
    s.parse()
}

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

let parse_and_double = try_compose!(
    wrap!(parse),
    wrap!(double)
);

match parse_and_double("42") {
    Ok(n) => println!("{}", n), // 输出: 84
    Err(e) => println!("Error: {}", e),
}

完整示例demo

// 完整示例展示func_wrap的主要功能
use func_wrap::{wrap, compose, pipe, curry, partial, lazy_chain, try_compose};
use std::num::ParseIntError;

fn main() {
    // 1. 简单包装示例
    let wrapped_add = wrap!(add);
    println!("简单包装: {}", wrapped_add(2, 3)); // 输出: 5
    
    // 2. 函数组合示例
    let composed = compose!(wrap!(double), wrap!(add_one));
    println!("函数组合: {}", composed(5)); // 输出: 11
    
    // 3. 管道式调用示例
    let pipeline = pipe!(wrap!(square), wrap!(subtract_five));
    println!("管道调用: {}", pipeline(4)); // 输出: 11
    
    // 4. 柯里化示例
    let curried = curry!(add_three);
    let result = curried(5)(3)(2);
    println!("柯里化: {}", result); // 输出: 10
    
    // 5. 部分应用示例
    let say_hello = partial!(greet, "Hello");
    println!("部分应用: {}", say_hello("Rust")); // 输出: "Hello, Rust!"
    
    // 6. 惰性求值链示例
    let lazy_eval = lazy_chain!(
        wrap!(parse),
        wrap!(negate),
        wrap!(to_string)
    );
    println!("惰性求值: {}", lazy_eval("42").force()); // 输出: "-42"
    
    // 7. 错误处理组合示例
    let parse_and_double = try_compose!(
        wrap!(parse),
        wrap!(double)
    );
    match parse_and_double("42") {
        Ok(n) => println!("错误处理: {}", n), // 输出: 84
        Err(e) => println!("Error: {}", e),
    }
}

// 辅助函数定义
fn add(a: i32, b: i32) -> i32 { a + b }
fn add_one(x: i32) -> i32 { x + 1 }
fn double(x: i32) -> i32 { x * 2 }
fn square(x: i32) -> i32 { x * x }
fn subtract_five(x: i32) -> i32 { x - 5 }
fn add_three(a: i32, b: i32, c: i32) -> i32 { a + b + c }
fn greet(greeting: &str, name: &str) -> String {
    format!("{}, {}!", greeting, name)
}
fn parse(s: &str) -> i32 { s.parse().unwrap() }
fn negate(x: i32) -> i32 { -x }
fn to_string(x: i32) -> String { x.to_string() }

性能考虑

func_wrap在编译时进行大量优化，生成的代码与手写组合函数性能相当。编译器会内联大部分包装调用，几乎没有运行时开销。

适用场景

• 需要构建复杂函数管道的应用
• 需要高度复用函数逻辑的场景
• 函数式编程风格的项目
• 需要延迟执行的函数链

通过func_wrap，你可以用声明式的方式构建复杂的函数逻辑，同时保持代码的简洁和可读性。