Generics 应为泛型类型，但找到具体类型（实现特征绑定的）

我有两个方法，它们做的事情非常相似，我确实希望使用泛型和特征边界进行重构

以下是我的示例中的两种工作方法

fn some_method_a(some_arg: u8) -> (Mode, Vec<A>)
{
    let mode = match some_arg {
        0 => Mode::ZERO,
        _ => Mode::NOTZERO,
    };

    let some_as = vec![A::new(0), A::new(1)];
    (mode, some_as)
}

fn some_method_b(some_arg: u8) -> (Mode, Vec<B>)
{
    let mode = match some_arg {
        0 => Mode::ZERO,
        _ => Mode::NOTZERO,
    };

    let some_bs = vec![B::new("Testing".to_string())];
    (mode, some_bs)
}

以下是节目的其余部分：

#[derive(Debug)]
enum Mode {
    ZERO,
    NOTZERO,
}

trait Filterable {
    fn get_some_data(&self) -> u8 {
        0
    }
}

struct A {
    some_data: u8,
}

struct B {
    some_other_data: String,
}

impl A {
    fn new(some_data: u8) -> A {
        A { some_data }
    }
}

impl B {
    fn new(some_other_data: String) -> B {
        B { some_other_data }
    }
}

impl Filterable for A {
    fn get_some_data(&self) -> u8 {
        self.some_data
    }
}

impl Filterable for B {}

---

对于一个或多个B或B结构的模式和向量，需要做些什么？< / P> > P>我对锈蚀泛型的理解是，它们比C++可能更像C++模板，在编译时它们是单形化和扩展的。 从本质上讲，它的作用是：

fn some_method<T>(some_arg: u8) -> (Mode, Vec<T>)
    where T: Filterable,

这将完全删除泛型，而只返回装箱的

Filterable

实现实例的向量

当然，方法主体现在也必须变成：

match &mode {
    &Mode::ZERO => (mode, vec![Box::new(A::new(0)), Box::new(A::new(1))]),
    _ => (mode, vec![Box::new(B::new("Testing".to_string()))]),
}

导致代码编译

fn some_method<T>(some_arg: u8) -> (Mode, Vec<T>)
    where T: Filterable,

fn some_method(some_arg: u8) -> (Mode, Vec<Box<Filterable>>)

match &mode {
    &Mode::ZERO => (mode, vec![Box::new(A::new(0)), Box::new(A::new(1))]),
    _ => (mode, vec![Box::new(B::new("Testing".to_string()))]),
}