rust - 是否可以在集合中存储实现相同的非对象安全特征的不同具体类型？

Question

由于通用函数，类似这样的特征可防止&dyn DoAction:

trait DoAction {
    fn action<T: T1 + T2>(&self, s: &T) { 
        s.action_t1();
        s.action_t2();
    }
}

有没有一种方法可以写一个函数，其中 Vec包含不同的具体类型，但是它们都实现了trait DoAction？

fn run_all(runners: Vec<&impl DoAction>) {}

我要解决的主要问题是能够遍历这些不同的具体类型-但由于通用特征函数，我无法使用 How do I create a heterogeneous collection of objects?中描述的 Vec<&dyn T>特征对象。
例如:

struct SA {
    sa: u32,
}

struct SB {
    sb: u32,
}

trait T1 {
    fn action_t1(&self) -> bool {
        true
    }
}

trait T2 {
    fn action_t2(&self) -> bool {
        true
    }
}

impl T1 for SA {}
impl T1 for SB {}
impl T2 for SA {}
impl T2 for SB {}

impl T1 for &SA {}
impl T1 for &SB {}
impl T2 for &SA {}
impl T2 for &SB {}

trait DoAction {
    fn action<T: T1 + T2>(&self, s: &T) {
        s.action_t1();
        s.action_t2();
    }
}

struct Runner1 {}
impl DoAction for Runner1 {}

struct Runner2 {}
impl DoAction for Runner2 {}

fn run_all(runners: Vec<&impl DoAction>, s: (impl T1 + T2)) {
    for r in runners {
        r.action(&s);
    }
}

fn main() {
    let a = SA { sa: 123 };

    let r1 = Runner1 {};
    let r2 = Runner2 {};

    let ls = vec![&r1, &r2];
    run_all(ls, &a);
}

Playground

Answer 1

由于此类函数仅适用于某些具体类型，因此您可以通过创建使该方法“具体化”并为实现DoAction的所有类型实现该特征的特征来解决此问题:

trait DoConcreteAction<T> {
    fn concrete_action(&self, s: &T);
}

impl<T, U> DoConcreteAction<U> for T
where
    T: DoAction,
    U: T1 + T2,
{
    fn concrete_action(&self, s: &U) {
        self.action(s)
    }
}

fn run_all<T>(runners: Vec<&dyn DoConcreteAction<T>>, s: &T) {
    for r in runners {
        r.concrete_action(&s);
    }
}

fn main() {
    let a = SA { sa: 123 };

    let r1 = Runner1 {};
    let r2 = Runner2 {};

    let ls: Vec<&dyn DoConcreteAction<SA>> = vec![&r1, &r2];
    run_all(ls, &a);
}

Permalink to the playground