如何在Rust中实现带动态类型参数的结构体引用？

Rust目前确实不支持直接创建&Foo<dyn Trait>这类引用，因为泛型结构体的类型参数无法直接替换为动态大小的dyn Trait来构造DST。最接近的实现方式是通过一层 trait 封装Foo的行为，让Bar持有 trait 对象引用：

trait Trait {
    fn do_something(&self);
}

// 封装Foo对外暴露的行为
trait FooWrapper {
    fn get_inner(&self) -> &dyn Trait;
}

// 为所有符合条件的Foo<T>实现Wrapper trait
impl<T: Trait> FooWrapper for Foo<T> {
    fn get_inner(&self) -> &dyn Trait {
        &self.inner
    }
}

struct Foo<T: Trait> {
    inner: T,
}

struct Bar<'a> {
    foo: &'a dyn FooWrapper,
}

这样Bar就能持有任意T类型的Foo实例引用，&dyn FooWrapper作为胖指针，包含数据指针和FooWrapper的虚表，满足动态持有不同Foo实例的需求，且Bar本身是Sized类型。

对于Foo<T: Trait, U: Trait>的情况，同样可以用自定义trait封装所有需要的动态行为：

trait Trait {
    fn do_something(&self);
}

// 封装Foo双参数的对外行为
trait FooDoubleWrapper {
    fn get_a(&self) -> &dyn Trait;
    fn get_b(&self) -> &dyn Trait;
}

// 为所有(T,U)组合实现Wrapper trait
impl<T: Trait, U: Trait> FooDoubleWrapper for Foo<T, U> {
    fn get_a(&self) -> &dyn Trait {
        &self.a
    }
    fn get_b(&self) -> &dyn Trait {
        &self.b
    }
}

struct Foo<T: Trait, U: Trait> {
    a: T,
    b: U,
}

struct Bar<'a> {
    foo: &'a dyn FooDoubleWrapper,
}

你设想的“为每个T与U的组合单独创建虚表”，在当前Rust中完全可行。上面的多参数示例就是这种思路的落地：当你为Foo<T,U>实现FooDoubleWrapper时，Rust会为每个不同的(T,U)组合生成对应的专属虚表，&dyn FooDoubleWrapper的胖指针只需要存储一个指向该组合虚表的指针，调用方法时就能通过这个虚表找到对应T和U的具体实现逻辑，完全符合你想要的效果。

Rust的泛型结构体布局是编译时由类型参数确定的，而dyn Trait是动态大小类型，无法在编译时确定Foo<dyn Trait>这类结构体的内存布局（比如字段的大小是动态的），因此语言层面不支持这种写法。而通过trait对象封装的方式，相当于把动态类型的细节隐藏在虚表之后，让Bar只需要处理固定大小的胖指针，既满足动态性需求，又符合Rust的类型安全规则。

内容的提问来源于stack exchange，提问作者A. Kriegman