如何创建包含同一泛型函数不同泛型类型实例的向量？

你的代码触发类型不匹配错误的核心原因是：decode::<MyIEa> 和 decode::<MyIEb> 是不同的函数类型——前者是for<'r> fn(&'r dyn IE) -> MyIEa，后者是for<'r> fn(&'r dyn IE) -> MyIEb。Rust的Vec要求所有元素必须是同一类型，直接将它们放入同一个向量自然会报错。

你看到的错误信息翻译为：

预期结构体Box<[for<'r> fn(&'r (dyn IE + 'r)) {decode::<MyIEa>}], _>，实际得到结构体Box<[for<'r> fn(&'r (dyn IE + 'r)); 2], std::alloc::Global>

本质是Rust无法自动将两个异构的函数类型统一为向量的元素类型。以下是几种可行的解决方案：

方案1：统一函数返回 trait object #

修改decode函数，让它返回Box<dyn IE>，这样不同泛型实例的函数类型会被统一：

pub fn test_ex7() {
    trait IE {}
    
    struct MyIEa {}
    impl IE for MyIEa {}
    
    struct MyIEb {}
    impl IE for MyIEb {}
    
    // 调整返回类型为Box<dyn IE>，并为T添加'static约束（适配trait object生命周期）
    fn decode<T: IE + 'static>(ie: &dyn IE) -> Box<dyn IE> {
        // 补充实际解码逻辑，示例中直接返回T的实例
        Box::new(T {})
    }
    
    // 显式指定向量类型，即可容纳两个泛型函数实例
    let v: Vec<fn(&dyn IE) -> Box<dyn IE>> = vec![
        decode::<MyIEa>,
        decode::<MyIEb>,
    ];
}

方案2：用枚举封装异构函数类型 #

如果不想修改decode的返回类型，可以定义枚举来包裹不同的函数类型，实现容器元素的类型统一：

pub fn test_ex7() {
    trait IE {}
    
    struct MyIEa {}
    impl IE for MyIEa {}
    
    struct MyIEb {}
    impl IE for MyIEb {}
    
    fn decode<T: IE>(ie: &dyn IE) -> T {
        // 示例用unsafe生成实例，实际需替换为真实解码逻辑
        unsafe { std::mem::zeroed() }
    }
    
    // 定义枚举，分别对应两种解码函数类型
    enum DecoderFn {
        A(fn(&dyn IE) -> MyIEa),
        B(fn(&dyn IE) -> MyIEb),
    }
    
    // 向量存储枚举实例，实现类型统一
    let v = vec![
        DecoderFn::A(decode::<MyIEa>),
        DecoderFn::B(decode::<MyIEb>),
    ];
    
    // 使用时通过模式匹配调用对应函数
    for decoder in v {
        match decoder {
            DecoderFn::A(f) => { let _: MyIEa = f(&MyIEa {}); },
            DecoderFn::B(f) => { let _: MyIEb = f(&MyIEb {}); },
        }
    }
}

方案3：用 trait object 包裹函数逻辑 #

如果需要更灵活的处理，可以将每个函数包装为Box<dyn Fn(&dyn IE) -> Box<dyn IE>>，无需修改原decode函数：

pub fn test_ex7() {
    trait IE {}
    
    struct MyIEa {}
    impl IE for MyIEa {}
    
    struct MyIEb {}
    impl IE for MyIEb {}
    
    fn decode<T: IE + 'static>(ie: &dyn IE) -> T {
        // 补充实际解码逻辑
        T {}
    }
    
    // 向量存储包裹后的函数对象
    let v: Vec<Box<dyn Fn(&dyn IE) -> Box<dyn IE>>> = vec![
        Box::new(|ie| Box::new(decode::<MyIEa>(ie))),
        Box::new(|ie| Box::new(decode::<MyIEb>(ie))),
    ];
    
    // 使用示例
    for f in v {
        let _: Box<dyn IE> = f(&MyIEa {});
    }
}

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