Может ли Rust перебирать все типы в модуле?

У меня есть подобная черта для описания структуры типа, если я знаю тип во время компиляции, конечно, я могу проверить все его ассоциированные константы, ассоциированные типы и статические функции-члены. Но дело в том, что в модуле определены сотни (или даже больше) типов, которые удовлетворяют этой черте TypeModule, но я получил только значение TypeID во время выполнения, как я могу определить, какой тип является правильным Я хочу и проверяю все его связанные константы, ассоциированные типы и статические функции-члены?

pub trait Value: std::fmt::Debug {
    const SERIALIZED_SIZE_HINT: usize; //此NBT数据类型序列化的预估大小
    fn deserialize_from(src: &[u8]) -> DynamicValue;//必须正确实现，返回的type_id必须正确，不允许失败，无论src为何都必须返回一个正确的DynamicValue
    fn serialize_into(dynamic_value: &DynamicValue) -> Vec<u8>;//不允许失败，因为内存中的DynamicValue的数据一定处于正确的状态
}
///每个ID写一个类型，实现这个Trait，静态分发用
pub trait TypeModule {
    const TYPE_ID: TypeID<'static>;
    const TAG_LIST: &'static [Tag];
    type BlockValue: Value;
    type EntityValue: Value;
    type ItemValue: Value;
    fn get_type_info() -> TypeInfo {
        let block = if !is_same_type::<Self::BlockValue, ()>() {Some(SerializeDeserializeFunctions{
            deserialize_from: Self::BlockValue::deserialize_from,
            serialize_into: Self::BlockValue::serialize_into,
            serialize_size_hint: Self::BlockValue::SERIALIZED_SIZE_HINT,
        })} else {None};
        let entity = if !is_same_type::<Self::EntityValue, ()>() {Some(SerializeDeserializeFunctions{
            deserialize_from: Self::EntityValue::deserialize_from,
            serialize_into: Self::EntityValue::serialize_into,
            serialize_size_hint: Self::EntityValue::SERIALIZED_SIZE_HINT,
        })} else {None};
        let item = if !is_same_type::<Self::ItemValue, ()>() {Some(SerializeDeserializeFunctions{
            deserialize_from: Self::ItemValue::deserialize_from,
            serialize_into: Self::ItemValue::serialize_into,
            serialize_size_hint: Self::ItemValue::SERIALIZED_SIZE_HINT,
        })} else {None};
        TypeInfo {
            type_id: Self::TYPE_ID,
            tags: Self::TAG_LIST,
            block_functions: block,
            entity_functions: entity,
            item_functions: item,
        }
    }
}

Можно ли написать код, повторяющий все типы в модуле, чтобы я мог сравнить их ассоциированный TYPE_ID с заданным значением во время выполнения и получить правильный TAG_LIST, SERIALIZED_SIZE_HINT и все указатели на функции-члены?

Ближайшая попытка, которую я предпринял, — это добавление функции в TypeModule для преобразования типа в значение TypeInfo:

///Helper Function
struct SameType<T1, T2> {}
impl<T1, T2> SameType<T1, T2> {
    const VALUE :bool = false;
}
impl<T> SameType<T, T> {
    const VALUE :bool = true;
}
fn is_same_type<T1, T2>() -> bool {SameType::<T1, T2>::VALUE}

#[derive(PartialEq,Eq,Copy,Clone)]
pub enum Tag {

}

pub struct SerializeDeserializeFunctions {
    deserialize_from: fn(&[u8]) -> DynamicValue,
    serialize_into: fn(&DynamicValue) -> Vec<u8>,
    serialize_size_hint: usize,
}

///write an instance of this type for every id, for dynamic dispatching
pub struct TypeInfo {
    type_id: TypeID<'static>,
    tags: &'static [Tag],
    block_functions: Option<SerializeDeserializeFunctions>,
    entity_functions: Option<SerializeDeserializeFunctions>,
    item_functions: Option<SerializeDeserializeFunctions>,
}

Я могу превратить заранее известный тип в TypeInfo, но я не знаю, как проверить сотни типов модуля.