在Rust中能否将含泛型PhantomData的结构体存入同一Vec？

我定义了如下结构体：

struct Foo<T> {
    // ... 非泛型常量字段
    marker: PhantomData<T>    
}

由于PhantomData<T>是零大小类型，Foo<T>的大小在编译时可知，且所有Foo实例均可通过const构造。我希望创建一个vector或数组，存储带有不同T参数的Foo<T>实例，例如类似Vec<dyn Foo<_>>的形式，并将其传入函数：

fn func(foos: &[Foo<_>]) {
    // ...
}

func(&[Foo<i64>::new(), Foo<String>::new()]);

但这段代码无法通过编译，编译器认为Foo<A>与Foo<B>是不同类型，尽管它们的内存布局完全一致。

请问是否有实现方法或变通方案（包括使用unsafe）？

我不想使用trait，原因如下：

1. 使用trait约束会导致无法传入不同T的实例：

fn func<T: SomeTrait>(foos: &[T]);

这种写法无法传入混合类型的实例；
2. 使用dyn SomeTrait需要进行Boxing，而我希望避免这一点，且这在理论上并无必要。

我清楚Foo<T>的部分方法可能仅针对特定T约束实现，但所有T都适用的方法应仍可调用。

解决方案 #

方法1：定义非泛型包装结构体（安全实现） #

利用#[repr(transparent)]保证包装体与Foo<T>内存布局完全一致，通过安全转换实现类型擦除：

use std::marker::PhantomData;

struct Foo<T> {
    // 示例非泛型字段
    value: u32,
    marker: PhantomData<T>,
}

impl<T> Foo<T> {
    const fn new(value: u32) -> Self {
        Self {
            value,
            marker: PhantomData,
        }
    }

    // 所有T都适用的通用方法
    fn get_value(&self) -> u32 {
        self.value
    }
}

// 非泛型包装体，与Foo<T>布局完全一致
#[repr(transparent)]
struct FooErased {
    value: u32,
}

// 安全转换：布局一致且Foo<T>无自定义Drop逻辑
impl<T> From<Foo<T>> for FooErased {
    fn from(foo: Foo<T>) -> Self {
        unsafe { std::mem::transmute_copy(&foo) }
    }
}

// 为包装体实现通用方法，复用Foo<T>的逻辑
impl FooErased {
    fn get_value(&self) -> u32 {
        // 临时转为任意Foo<T>（如Foo<()>）调用方法，方法不依赖T
        let temp_foo: Foo<()> = unsafe { std::mem::transmute_copy(self) };
        temp_foo.get_value()
    }
}

// 统一参数类型的函数
fn func(foos: &[FooErased]) {
    for foo in foos {
        println!("Value: {}", foo.get_value());
    }
}

fn main() {
    let foo_i64 = Foo::<i64>::new(42);
    let foo_string = Foo::<String>::new(100);

    let erased_list = [foo_i64.into(), foo_string.into()];
    func(&erased_list);
}

方法2：直接转固定泛型参数（极简实现） #

直接将所有Foo<T>转为Foo<()>（或任意固定T），利用内存布局一致的特性实现：

use std::marker::PhantomData;

struct Foo<T> {
    value: u32,
    marker: PhantomData<T>,
}

impl<T> Foo<T> {
    const fn new(value: u32) -> Self {
        Self {
            value,
            marker: PhantomData,
        }
    }

    fn get_value(&self) -> u32 {
        self.value
    }
}

fn func(foos: &[Foo<()>]) {
    for foo in foos {
        println!("Value: {}", foo.get_value());
    }
}

fn main() {
    let foo_i64 = Foo::<i64>::new(42);
    let foo_string = Foo::<String>::new(100);

    // 安全转换：布局一致且无自定义Drop
    let erased_i64: Foo<()> = unsafe { std::mem::transmute_copy(&foo_i64) };
    let erased_string: Foo<()> = unsafe { std::mem::transmute_copy(&foo_string) };

    func(&[erased_i64, erased_string]);
}

关键注意事项 #

• 必须确保所有Foo<T>内存布局完全一致：只要除PhantomData<T>外的字段都是非泛型的，这个条件就成立。
• 如果Foo<T>实现了自定义Drop，转换会变得不安全——drop时会处理错误的T类型。无自定义Drop的情况下是安全的。
• 仅针对特定T的方法无法在类型擦除后直接调用，必须恢复原T类型才能使用（需额外存储类型标识，会增加复杂度）。

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