如何在HashMap中存储实现带关联类型Block trait的结构体？

核心思路 #

由于Block trait的关联类型是静态绑定的，不同实现结构体的Inputs/Outputs类型无法直接统一，因此需要通过间接包装隐藏类型差异，对外提供统一的调用接口。

具体实现步骤 #

1. 完善统一输入输出枚举 #

确保BlockInputs和BlockOutputs覆盖所有可能的具体输入输出类型，并实现对应转换：

#[derive(Debug, Clone)]
enum BlockInputs {
    First(FirstInputs),
    Second(SecondInputs),
}

#[derive(Debug)]
enum BlockOutputs {
    First(FirstOutputs),
    Second(SecondOutputs),
}

// 具体输入转统一枚举
impl From<FirstInputs> for BlockInputs {
    fn from(val: FirstInputs) -> Self {
        BlockInputs::First(val)
    }
}

impl From<SecondInputs> for BlockInputs {
    fn from(val: SecondInputs) -> Self {
        BlockInputs::Second(val)
    }
}

// 具体输出转统一枚举
impl From<FirstOutputs> for BlockOutputs {
    fn from(val: FirstOutputs) -> Self {
        BlockOutputs::First(val)
    }
}

impl From<SecondOutputs> for BlockOutputs {
    fn from(val: SecondOutputs) -> Self {
        BlockOutputs::Second(val)
    }
}

2. 定义擦除类型差异的统一Trait #

创建一个对外暴露统一接口的Trait，内部处理类型转换：

trait ErasedBlock {
    fn do_something_erased(&self, inputs: &BlockInputs) -> Result<BlockOutputs, Box<dyn std::error::Error>>;
}

3. 为所有Block实现自动适配 #

通过泛型实现，将统一枚举转换为具体关联类型，调用原方法后再转回统一枚举：

impl<T: Block> ErasedBlock for T
where
    T::Inputs: TryFrom<BlockInputs>,
    <T::Inputs as TryFrom<BlockInputs>>::Error: std::error::Error + 'static,
    T::Outputs: Into<BlockOutputs>,
{
    fn do_something_erased(&self, inputs: &BlockInputs) -> Result<BlockOutputs, Box<dyn std::error::Error>> {
        // 转换为具体输入类型
        let specific_input = T::Inputs::try_from(inputs.clone())?;
        // 调用原Block方法
        let specific_output = self.do_something(&specific_input)?;
        // 转换为统一输出枚举
        Ok(specific_output.into())
    }
}

// 补充具体输入类型的反向转换（处理类型不匹配的错误）
impl TryFrom<BlockInputs> for FirstInputs {
    type Error = Box<dyn std::error::Error>;

    fn try_from(input: BlockInputs) -> Result<Self, Self::Error> {
        match input {
            BlockInputs::First(val) => Ok(val),
            _ => Err("输入类型不匹配FirstBlock".into()),
        }
    }
}

impl TryFrom<BlockInputs> for SecondInputs {
    type Error = Box<dyn std::error::Error>;

    fn try_from(input: BlockInputs) -> Result<Self, Self::Error> {
        match input {
            BlockInputs::Second(val) => Ok(val),
            _ => Err("输入类型不匹配SecondBlock".into()),
        }
    }
}

4. 构建注册表并使用 #

现在可以用统一的Box<dyn ErasedBlock>作为值类型存储所有Block实例：

use std::collections::HashMap;

fn main() {
    let mut registry: HashMap<String, Box<dyn ErasedBlock>> = HashMap::new();

    // 存入不同Block实例
    registry.insert("first_block".to_string(), Box::new(FirstBlock));
    registry.insert("second_block".to_string(), Box::new(SecondBlock));

    // 调用示例
    let test_input = BlockInputs::First(FirstInputs { num: 10 });
    if let Some(block) = registry.get("first_block") {
        let output = block.do_something_erased(&test_input).unwrap();
        println!("FirstBlock输出: {:?}", output);
    }
}

原方案失败原因 #

Rust中关联类型必须是具体类型，不能直接使用trait对象（如dyn Into<BlockInputs>）作为关联类型的取值——关联类型是静态确定的，而trait对象是动态分发的，二者无法兼容。通过上述包装，我们把类型差异隐藏在内部实现中，对外提供了静态统一的调用接口。

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