Rust中无需装箱即可向下转型已拥有的Any类型值吗？

方案一：使用Nightly版的Specialization特性（推荐，无分配、类型安全） #

Rust的specialization特性允许为泛型trait提供默认实现，同时为特定类型提供更具体的实现，全程无需堆分配：

#![feature(specialization)]

use std::fmt::Display;

enum StringIsSpecial {
    Special(String),
    NotSpecial,
}

// 为所有满足Display的类型提供默认实现
impl<T: Display> From<T> for StringIsSpecial {
    default fn from(_value: T) -> Self {
        StringIsSpecial::NotSpecial
    }
}

// 为String类型提供特殊实现，优先匹配
impl From<String> for StringIsSpecial {
    fn from(value: String) -> Self {
        StringIsSpecial::Special(value)
    }
}

该方案完全避免堆分配且类型安全，唯一限制是需要使用Nightly版本的Rust编译器。

方案二：稳定版无堆分配实现（需unsafe） #

如果必须使用稳定版Rust，可以通过TypeId判断类型，结合unsafe代码直接转换值，跳过装箱步骤：

use std::any::{Any, TypeId};
use std::fmt::Display;

enum StringIsSpecial {
    Special(String),
    NotSpecial,
}

impl<T: Any + Display> From<T> for StringIsSpecial {
    fn from(value: T) -> Self {
        if TypeId::of::<T>() == TypeId::of::<String>() {
            // 已通过TypeId确认T就是String，transmute操作安全
            unsafe { StringIsSpecial::Special(std::mem::transmute(value)) }
        } else {
            StringIsSpecial::NotSpecial
        }
    }
}

此处的unsafe是安全的：我们已经通过TypeId严格验证了当前类型为String，transmute不会引发内存布局不匹配问题。

方案三：稳定版类型安全无unsafe实现 #

若不想使用unsafe，可以为String单独实现From，同时借助辅助trait为其他类型实现泛版逻辑，避免冲突：

use std::fmt::Display;

enum StringIsSpecial {
    Special(String),
    NotSpecial,
}

// 为String单独实现，优先匹配
impl From<String> for StringIsSpecial {
    fn from(value: String) -> Self {
        StringIsSpecial::Special(value)
    }
}

// 辅助trait，标记非String类型
trait NotString {}
impl<T: Display> NotString for T where T: !std::convert::From<String> {}

// 为所有非String且实现Display的类型实现From
impl<T: Display + NotString> From<T> for StringIsSpecial {
    fn from(_value: T) -> Self {
        StringIsSpecial::NotSpecial
    }
}

该方案完全类型安全且无堆分配，仅需额外的辅助trait解决泛型实现与具体类型实现的冲突问题。

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