只有三种方法可以在Rust中完成您正在尝试的工作。每种方式都有自己的权衡，所以哪种更好将取决于您的用例。

使用泛型

trait Namable {}

struct UserCertification<T> {
    current_work: T,
}

impl<T: Namable> UserCertification<T> {
    fn new (current_work: T) -> Self {
        UserCertification { current_work, }
    }
}

这可能是最简单的方法，也是最有效的内存使用和性能。主要的缺点是，你不能在同一代码中混合使用多种类型，也不能动态地更改存储在变量中的类型：

struct Foo;
impl Namable for Foo {}
struct Bar;
impl Namable for Bar {}

// Impossible:
let v = vec![ UserCertification::new (Foo), UserCertification::new (Bar), ];

// Impossible too:
let mut v = UserCertification::new (Foo);
v = UserCertification::new (Bar);

Playground

使用trait对象

trait对象写为dyn Namable，并且它 * 必须 * 在某种引用后面，例如。&dyn Namable、Box<dyn Namable>、Rc<dyn Namable>或Arc<dyn Namable>。

trait Namable {}

struct UserCertification {
    current_work: Box<dyn Namable>,
}

impl UserCertification {
    fn new<T: Namable + 'static> (current_work: T) -> Self {
        UserCertification { current_work: Box::new (current_work), }
    }
}

Playground
这相当容易使用，允许非常广泛的用途，包括混合不同的类型和动态更改，但它也是三种解决方案中最慢的。这也是大多数高级语言做事情的方式（例如Java、Python等）。但是some traits cannot be made into trait objects。

使用枚举

trait Namable {
    fn name (&self) -> &'static str;
}

struct Foo;
impl Namable for Foo {
    fn name (&self) -> &'static str { "Foo" }
}
struct Bar;
impl Namable for Bar {
    fn name (&self) -> &'static str { "Bar" }
}

enum AllNamables {
    Foo (Foo),
    Bar (Bar),
}
impl Namable for AllNamables {
    fn name (&self) -> &'static str {
        match self {
            AllNamables::Foo (f) => f.name(),
            AllNamables::Bar (b) => b.name(),
        }
    }
}
impl From<Foo> for AllNamables {
    fn from (f: Foo) -> Self { AllNamables::Foo (f) }
}
impl From<Bar> for AllNamables {
    fn from (b: Bar) -> Self { AllNamables::Bar (b) }
}

struct UserCertification {
    current_work: AllNamables,
}

impl UserCertification {
    fn new<T: Into<AllNamables>> (current_work: T) -> Self {
        UserCertification { current_work: current_work.into(), }
    }
}

Playground
这种解决方案允许混合不同的类型并动态更改，它通常比现代CPU上的trait对象解决方案更快。但是：

• 它需要预先知道您需要的所有可能类型。
• 它需要大量的样板文件（尽管像enum_dispatch这样的板条箱可能会有所帮助）。