Rust稳定版手动特化：具体类型转泛型的实现方案探讨

我正在编写Rust代码，希望将通用功能封装到一处。现有代码如下：

pub struct Foo { }

pub fn process_foo() -> Result<Foo, X>;
pub fn process_usize() -> Result<usize, X>;

不想保留这些独立函数，希望封装为泛型函数pub fn process<T>() -> Result<T, X>;。但Rust稳定版暂不支持特化，因此尝试了以下方案：
定义枚举TypeInfo和trait WithTypeInfo，为Foo和usize实现该trait，修改泛型函数为process<T: WithTypeInfo>，通过匹配TypeInfo调用对应函数，但编译时无法完成Result<Foo,X>到Result<T,X>的类型转换。

于是使用unsafe宏实现了转换，代码如下：

pub fn process<T: WithTypeInfo>() -> Result<T, X> {

    macro_rules! mutate {
        ( $e:expr ) => {
            {
                let item = { $e }?;
                let src = core::ptr::from_ref(&item).cast::<T>();
                let dst = unsafe { core::ptr::read(src) };

                #[allow(forgetting_copy_types, clippy::forget_non_drop)]
                {
                    std::mem::forget(item);
                }

                Ok(dst)
            }
    };

    match T::type_info() {
        TypeInfo::Foo => mutate!(process_foo()),
        TypeInfo::Usize => mutate!(process_usize()),
    }
}

该宏通过指针重解释完成类型转换，添加std::mem::forget避免Drop重复执行，测试可用。请问该设计是否合理？是否存在未发现的缺陷？或有更优实现方式？

现有实现的缺陷 #

• 类型安全风险极高：代码完全依赖WithTypeInfo实现的正确性，如果某个类型的type_info()返回错误枚举值，会直接触发指针类型转换错误，导致未定义行为（UB），比如内存损坏、程序崩溃等。
• 冗余处理Copy类型：对usize这类Copy类型使用mem::forget完全没必要，虽通过Clippy允许，但逻辑冗余，后续扩展类型时容易引入新问题。
• 代码可读性与维护性差：宏+unsafe指针转换的写法晦涩，远不如类型安全的实现直观，后续修改或扩展功能的成本很高。

更优的类型安全实现方式 #

无需使用unsafe代码，通过调整trait设计即可实现需求：

方案1：直接在trait中定义处理方法 #

把处理逻辑绑定到trait上，让每个类型自行实现对应的处理逻辑：

pub trait Processable {
    fn process() -> Result<Self, X>;
}

impl Processable for Foo {
    fn process() -> Result<Self, X> {
        process_foo()
    }
}

impl Processable for usize {
    fn process() -> Result<Self, X> {
        process_usize()
    }
}

// 泛型函数直接调用trait方法
pub fn process<T: Processable>() -> Result<T, X> {
    T::process()
}

这种方式完全类型安全，无unsafe代码，逻辑清晰，符合Rust的trait调度机制，稳定版完全支持。

方案2：关联函数绑定原有处理逻辑 #

如果必须保留process_foo和process_usize函数，可通过trait的关联函数绑定，避免unsafe转换：

pub enum TypeInfo {
    Foo,
    Usize,
}

pub trait WithTypeInfo {
    const TYPE: TypeInfo;
    fn process() -> Result<Self, X>;
}

impl WithTypeInfo for Foo {
    const TYPE: TypeInfo = TypeInfo::Foo;
    fn process() -> Result<Self, X> {
        process_foo()
    }
}

impl WithTypeInfo for usize {
    const TYPE: TypeInfo = TypeInfo::Usize;
    fn process() -> Result<Self, X> {
        process_usize()
    }
}

pub fn process<T: WithTypeInfo>() -> Result<T, X> {
    T::process()
}

同样无需unsafe，把类型对应的处理逻辑封装在trait实现中，泛型函数直接调用即可，彻底规避指针转换的风险。

总结 #

现有unsafe实现存在严重的类型安全隐患，且维护成本高。推荐使用基于trait的类型安全方案，既符合Rust的设计理念，又能在稳定版中正常工作。

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