为 dyn 对象实现特征时的神秘生命周期问题

Question

考虑以下玩具示例：

use std::cmp::Ordering;

pub trait SimpleOrder {
    fn key(&self) -> u32;
}

impl PartialOrd for dyn SimpleOrder {
    fn partial_cmp(&self, other: &dyn SimpleOrder) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for dyn SimpleOrder {
    fn cmp(&self, other: &dyn SimpleOrder) -> Ordering {
        self.key().cmp(&other.key())
    }
}

impl PartialEq for dyn SimpleOrder {
    fn eq(&self, other: &dyn SimpleOrder) -> bool {
        self.key() == other.key()
    }
}

impl Eq for SimpleOrder {}

这不会编译。它声称partial_cmp 的实现存在终身问题：

error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
 --> src/main.rs:9:23
  |
9 |         Some(self.cmp(other))
  |                       ^^^^^
  |
note: first, the lifetime cannot outlive the anonymous lifetime #2 defined on the method body at 8:5...
 --> src/main.rs:8:5
  |
8 | /     fn partial_cmp(&self, other: &dyn SimpleOrder) -> Option<Ordering> {
9 | |         Some(self.cmp(other))
10| |     }
  | |_____^
note: ...so that the declared lifetime parameter bounds are satisfied
 --> src/main.rs:9:23
  |
9 |         Some(self.cmp(other))
  |                       ^^^^^
  = note: but, the lifetime must be valid for the static lifetime...
  = note: ...so that the types are compatible:
          expected std::cmp::Eq
             found std::cmp::Eq

我真的不明白这个错误。特别是 “预期的 std::cmp::Eq 发现 std::cmp::Eq” 令人费解。

如果我手动内联调用，它编译得很好：

fn partial_cmp(&self, other: &dyn SimpleOrder) -> Option<Ordering> {
    Some(self.key().cmp(&other.key()))
}

这是怎么回事？

Answer 1

Trait 对象类型具有关联的生命周期限制，但可以省略。一个完整的 trait 对象类型写成 dyn Trait + 'a（当引用后面时，必须在其周围添加括号：&(dyn Trait + 'a)）。

棘手的部分是当生命周期被省略时，the rules are a bit complicated。

首先，我们有：

impl PartialOrd for dyn SimpleOrder {

在这里，编译器推断+ 'static。 impl 块（从 Rust 1.32.0 开始）永远不会引入生命周期参数。

接下来，我们有：

    fn partial_cmp(&self, other: &dyn SimpleOrder) -> Option<Ordering> {

other 的类型被推断为&'b (dyn SimpleOrder + 'b)，其中'b 是在partial_cmp 上引入的隐式生命周期参数。

    fn partial_cmp<'a, 'b>(&'a self, other: &'b (dyn SimpleOrder + 'b)) -> Option<Ordering> {

所以现在我们有了self 的类型为&'a (dyn SimpleOrder + 'static) 而other 的类型为&'b (dyn SimpleOrder + 'b)。有什么问题？

确实，cmp 没有给出任何错误，因为它的实现不需要两个 trait 对象的生命周期相等。为什么partial_cmp 关心呢？

因为partial_cmp 正在调用Ord::cmp。在对特征方法的调用进行类型检查时，编译器会检查特征中的签名。让我们回顾一下这个签名：

pub trait Ord: Eq + PartialOrd<Self> {
    fn cmp(&self, other: &Self) -> Ordering;

该特征要求other 的类型为Self。这意味着当partial_cmp 调用cmp 时，它会尝试将&'b (dyn SimpleOrder + 'b) 传递给需要&'b (dyn SimpleOrder + 'static) 的参数，因为Self 是dyn SimpleOrder + 'static。这个转换无效（'b不能转换成'static），所以编译器报错。

那么，为什么在实现Ord时将other的类型设置为&'b (dyn SimpleOrder + 'b)是有效的呢？因为&'b (dyn SimpleOrder + 'b) 是supertype 的&'b (dyn SimpleOrder + 'static)，并且Rust 允许您在实现特征方法时将参数类型替换为其超类型之一（它使该方法更加通用，即使它显然在类型中使用得不多检查）。

---

为了使您的实现尽可能通用，您应该在impls 上引入生命周期参数：

use std::cmp::Ordering;

pub trait SimpleOrder {
    fn key(&self) -> u32;
}

impl<'a> PartialOrd for dyn SimpleOrder + 'a {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl<'a> Ord for dyn SimpleOrder + 'a {
    fn cmp(&self, other: &Self) -> Ordering {
        self.key().cmp(&other.key())
    }
}

impl<'a> PartialEq for dyn SimpleOrder + 'a {
    fn eq(&self, other: &Self) -> bool {
        self.key() == other.key()
    }
}

impl<'a> Eq for dyn SimpleOrder + 'a {}