Rust 1.24.0中如何创建带泛型参数的函数向量？

嘿，我来帮你搞定这个问题！在Rust里，哪怕两个函数的泛型签名完全一致，它们的底层类型也是独一无二的——每个函数都是自己专属的类型，这就是直接塞进Vec会触发编译错误的核心原因。下面分两部分给你清晰的解决方案：

一、将函数存入Vec的两种方法 #

1. 针对具体泛型参数测试（简单直接） #

如果你的测试只针对特定类型（比如i32、String），可以先把泛型函数实例化成具体类型的函数，这样它们的类型就统一了，直接放进Vec毫无压力。

举个例子：

use std::fmt::Debug;

// 两个同泛型签名的函数
fn foo<T: Debug>(val: T) -> String {
    format!("Foo: {:?}", val)
}

fn bar<T: Debug>(val: T) -> String {
    format!("Bar: {:?}", val)
}

fn main() {
    // 实例化为针对i32的函数，类型统一为`fn(i32) -> String`
    let test_cases = vec![
        (foo::<i32>, "Foo: 42".to_string()),
        (bar::<i32>, "Bar: 42".to_string())
    ];
    
    // 遍历执行测试
    for (func, expected) in test_cases {
        assert_eq!(func(42), expected);
    }
}

2. 保留泛型灵活性（进阶方案） #

如果想保留函数的泛型能力，不绑定到具体类型，那可以用trait对象结合高阶 trait bound（HRTB）——Rust 1.24已经支持HRTB，所以完全可行。

步骤如下：

1. 定义一个封装泛型函数行为的trait
2. 为所有符合泛型签名的函数实现这个trait
3. 将函数包装成trait对象存入Vec

代码示例：

use std::fmt::Debug;

// 定义一个trait来封装泛型函数行为
trait GenericDebugFunc {
    fn call<T: Debug>(&self, val: T) -> String;
}

// 为所有符合`for<T: Debug> Fn(T) -> String`签名的函数实现trait
impl<F> GenericDebugFunc for F
where
    F: for<T: Debug> Fn(T) -> String,
{
    fn call<T: Debug>(&self, val: T) -> String {
        self(val)
    }
}

// 测试用的泛型函数
fn foo<T: Debug>(val: T) -> String {
    format!("Foo: {:?}", val)
}

fn bar<T: Debug>(val: T) -> String {
    format!("Bar: {:?}", val)
}

fn main() {
    // 将函数包装成trait对象存入Vec（注意Rust 1.24不用`dyn`关键字，直接写trait名）
    let funcs: Vec<Box<GenericDebugFunc>> = vec![Box::new(foo), Box::new(bar)];
    
    // 遍历测试不同类型的输入
    for func in funcs {
        assert_eq!(func.call(42), "Foo: 42".to_string());
        assert_eq!(func.call("hello"), "Foo: \"hello\"".to_string());
    }
}

二、更优的测试复用方法：使用宏！ #

用Vec遍历测试虽然简单，但有个明显的缺点：一旦某个测试失败，你很难快速定位到是哪个函数哪个用例出了问题。而Rust的宏可以为每个函数每个测试用例生成独立的测试函数，失败时能直接看到具体的测试名称，排查效率高得多。

基础测试宏 #

先写一个通用的测试宏，接受函数名、测试函数名、输入值和预期结果：

use std::fmt::Debug;

fn foo<T: Debug>(val: T) -> String {
    format!("Foo: {:?}", val)
}

fn bar<T: Debug>(val: T) -> String {
    format!("Bar: {:?}", val)
}

// 定义测试宏
macro_rules! test_generic_func {
    ($func:ident, $test_name:ident, $input:expr, $expected:expr) => {
        #[test]
        fn $test_name() {
            let result = $func($input);
            assert_eq!(result, $expected);
        }
    };
}

// 为每个函数生成测试
test_generic_func!(foo, test_foo_i32, 42, "Foo: 42".to_string());
test_generic_func!(foo, test_foo_string, "hello", "Foo: \"hello\"".to_string());
test_generic_func!(bar, test_bar_i32, 42, "Bar: 42".to_string());
test_generic_func!(bar, test_bar_string, "hello", "Bar: \"hello\"".to_string());

批量测试宏（更高效） #

如果要给多个函数跑相同的测试用例，可以写一个更强大的宏，一次性为所有函数生成测试：

use std::fmt::Debug;

fn foo<T: Debug>(val: T) -> String {
    format!("Foo: {:?}", val)
}

fn bar<T: Debug>(val: T) -> String {
    format!("Bar: {:?}", val)
}

// 批量测试宏：接受多个函数和测试输入，自动生成对应预期值
macro_rules! test_all_funcs {
    ($($func:ident => $prefix:expr),*; $input:expr) => {
        $(
            #[test]
            fn test_$func_$(stringify!($input))() {
                let expected = format!("{}: {:?}", $prefix, $input);
                let result = $func($input);
                assert_eq!(result, expected);
            }
        )*
    };
}

// 给foo和bar同时测试i32和String用例
test_all_funcs!(foo => "Foo", bar => "Bar"; 42);
test_all_funcs!(foo => "Foo", bar => "Bar"; "hello");

这样一来，你只需要写几行宏调用，就能为所有符合签名的函数生成完整的测试套件，既高效又清晰。

内容的提问来源于stack exchange，提问作者tleyden