我为另一个特征实现了一个特征，但不能从两个特征调用方法

Question

我有一个特质叫做 Sleep:

pub trait Sleep {
    fn sleep(&self);
}

我可以为每个结构提供不同的睡眠实现，但事实证明大多数人的睡眠方式非常少。你可以睡在床上：

pub trait HasBed {
    fn sleep_in_bed(&self);
    fn jump_on_bed(&self);
}

impl Sleep for HasBed {
    fn sleep(&self) {
        self.sleep_in_bed()
    }
}

如果你在露营，你可以睡在帐篷里：

pub trait HasTent {
    fn sleep_in_tent(&self);
    fn hide_in_tent(&self);
}

impl Sleep for HasTent {
    fn sleep(&self) {
        self.sleep_in_tent()
    }
}

有一些奇怪的案例。我有一个朋友可以靠墙睡觉，但大多数人，大多数时候，都陷入了一些简单的情况。

我们定义一些结构并让它们休眠：

struct Jim;

impl HasBed for Jim {
    fn sleep_in_bed(&self) {}
    fn jump_on_bed(&self) {}
}

struct Jane;

impl HasTent for Jane {
    fn sleep_in_tent(&self) {}
    fn hide_in_tent(&self) {}
}

fn main() {
    use Sleep;
    let jim = Jim;
    jim.sleep();

    let jane = Jane;
    jane.sleep();
}

呃哦！编译错误：

error[E0599]: no method named `sleep` found for type `Jim` in the current scope
  --> src/main.rs:44:9
   |
27 | struct Jim;
   | ----------- method `sleep` not found for this
...
44 |     jim.sleep();
   |         ^^^^^
   |
   = help: items from traits can only be used if the trait is implemented and in scope
   = note: the following trait defines an item `sleep`, perhaps you need to implement it:
           candidate #1: `Sleep`

error[E0599]: no method named `sleep` found for type `Jane` in the current scope
  --> src/main.rs:47:10
   |
34 | struct Jane;
   | ------------ method `sleep` not found for this
...
47 |     jane.sleep();
   |          ^^^^^
   |
   = help: items from traits can only be used if the trait is implemented and in scope
   = note: the following trait defines an item `sleep`, perhaps you need to implement it:
           candidate #1: `Sleep`

这个编译器错误很奇怪，因为如果实现另一个特征的特征有问题，我希望在我这样做的时候听到它，而不是在我尝试使用结果。

在此示例中，只有 2 个结构和 2 种休眠方式，但在一般情况下，有很多结构和几种休眠方式（但方式没有结构那么多）。

Bed 主要是 Sleep 的实现，但在一般情况下 Bed 有很多用途，可以实现很多东西。

唯一显而易见的方法是将 impl Sleep for... 转换成一个宏，构造它们自己使用，但这看起来很老套和糟糕。

Answer 1

您需要为实现第一个特征的对象实现第二个特征:

impl<T> Sleep for T
where
    T: HasBed,
{
    fn sleep(&self) {
        self.sleep_in_bed()
    }
}

之前，您为特征类型实现 Sleep，更好地表示为 dyn HasBed。有关详细信息，请参阅。

但是，一旦您添加第二个一揽子实施，这就会中断：

impl<T> Sleep for T
where
    T: HasTent,
{
    fn sleep(&self) {
        self.sleep_in_tent()
    }
}

有

error[E0119]: conflicting implementations of trait `Sleep`:
  --> src/main.rs:24:1
   |
10 | / impl<T> Sleep for T
11 | | where
12 | |     T: HasBed,
13 | | {
...  |
16 | |     }
17 | | }
   | |_- first implementation here
...
24 | / impl<T> Sleep for T
25 | | where
26 | |     T: HasTent,
27 | | {
...  |
30 | |     }
31 | | }
   | |_^ conflicting implementation

有可能实现HasBed和HasTent。如果出现同时实现两者的东西，那么代码现在将是模棱两可的。解决方法是专业化，但目前还没有稳定的实施。

你是如何实现你的目标的？我想你已经提出了当前最好的解决方案——写一个宏。你也可以 write your own derive macro。宏确实没那么糟糕，但编写起来可能很笨拙。

另一件事，可能完全基于您为示例选择的名称，是将结构简单地嵌入到其他结构中，可选择地使它们成为 public。由于您对 Sleep 的实施基本上只取决于床/帐篷，因此这样做不会丢失任何功能。当然，有些人可能会觉得这样会破坏封装。您可以再次创建宏来实现各种委托。

trait Sleep {
    fn sleep(&self);
}

struct Bed;
impl Bed {
    fn jump(&self) {}
}
impl Sleep for Bed {
    fn sleep(&self) {}
}

struct Tent;
impl Tent {
    fn hide(&self) {}
}
impl Sleep for Tent {
    fn sleep(&self) {}
}

struct Jim {
    bed: Bed,
}
struct Jane {
    tent: Tent,
}

fn main() {
    let jim = Jim { bed: Bed };
    jim.bed.sleep();
}

Answer 2

我们可以在这里使用关联项。

pub trait Sleep: Sized {
    type Env: SleepEnv;

    fn sleep(&self, env: &Self::Env) {
        env.do_sleep(self);
    }

    fn get_name(&self) -> &'static str;
}

pub trait SleepEnv {
    fn do_sleep<T: Sleep>(&self, &T);
}

然后，我们实现两种不同的睡眠环境。

struct Bed;
struct Tent;

impl SleepEnv for Bed {
    fn do_sleep<T: Sleep>(&self, person: &T) {
        println!("{} is sleeping in bed", person.get_name());
    }
}

impl SleepEnv for Tent {
    fn do_sleep<T: Sleep>(&self, person: &T) {
        println!("{} is sleeping in tent", person.get_name());
    }
}

最后一块是它们的具体实现。

struct Jim;
struct Jane;

impl Sleep for Jim {
    type Env = Bed;
    fn get_name(&self) -> &'static str {
        "Jim"
    }
}

impl Sleep for Jane {
    type Env = Tent;
    fn get_name(&self) -> &'static str {
        "Jane"
    }
}

测试代码：

fn main() {
    let bed = Bed;
    let tent = Tent;

    let jim = Jim;
    let jane = Jane;
    jim.sleep(&bed);
    jane.sleep(&tent);
}

我为另一个特征实现了一个特征，但不能从两个特征调用方法

I implemented a trait for another trait but cannot call methods from both traits

traits

rust