rust - 特征关联类型生命周期和 self

Question

我有一个结构，它包装了一个 std::cell::Ref 并通过引用提供对底层值的访问。像这样:

use std::cell::Ref;

struct IntAccess<'a> {
    i: Ref<'a, i32>,
}

impl IntAccess<'_> {
    fn get(&self) -> &i32 {
        &self.i
    }
}

这很好用。由于我有多个这样的结构，我想定义一个共同的特征:

trait Access {
    type Item;
    fn get(&self) -> Self::Item;
}

但是，当我尝试为 IntAccess 实现 Access 时遇到了麻烦:

impl<'a> Access for IntAccess<'a> {
    type Item = &'a i32;

    fn get(&self) -> Self::Item {
        &self.i
    }
}

失败并出现以下错误:

error[E0495]: cannot infer an appropriate lifetime for borrow expression due to conflicting requirements
  --> src/main.rs:23:9
   |
23 |         &self.i
   |         ^^^^^^^
   |
note: first, the lifetime cannot outlive the anonymous lifetime defined here...
  --> src/main.rs:22:12
   |
22 |     fn get(&self) -> Self::Item {
   |            ^^^^^
note: ...so that reference does not outlive borrowed content
  --> src/main.rs:23:9
   |
23 |         &self.i
   |         ^^^^^^^
note: but, the lifetime must be valid for the lifetime `'a` as defined here...
  --> src/main.rs:19:6
   |
19 | impl<'a> Access for IntAccess<'a> {
   |      ^^
note: ...so that the types are compatible
  --> src/main.rs:22:33
   |
22 |       fn get(&self) -> Self::Item {
   |  _________________________________^
23 | |         &self.i
24 | |     }
   | |_____^
   = note: expected `<IntAccess<'a> as Access>`
              found `<IntAccess<'_> as Access>`

我想我有点明白编译器试图告诉我的意思:我正在尝试借用 self.i，它的匿名生命周期与 Self::的生命周期无关项目 ('a)。所以似乎需要的是以某种方式将 get 中的 self 的生命周期与 'a 的生命周期联系起来。有办法做到这一点吗？

我不得不承认我没有完全理解这个问题。由于我将生命周期 'a 传递给 Ref，并且 Ref 在内部存储了此生命周期的引用，所以在我看来它应该以某种方式可以从中获取具有生命周期 'a 的引用，而不必显式地将 self 也绑定(bind)到此生命周期。那么我在这里缺少什么？

Answer 1

你的理解是正确的。关于您的疑问，让我们命名生命周期以便于调试:

impl<'a> Access for IntAccess<'a> {
    type Item = &'a i32;

    fn get<'b>(&'b self) -> Self::Item {
        &self.i
    }
}

self类型为 &'b IntAccess<'a> . 'b短于或等于 'a - 这是 self 所必需的格式良好，即能够存在(否则，它将包含悬空引用)。

因此，我们不能借用 self超过'b - 或者我们可以做类似的事情:

let v: IntAccess<'a>;
let inner: &'a i32 = {
    let r: &'b IntAccess<'a> = &v;
    <IntAccess<'a> as Access>::get(r)
}
let mut_r: &mut IntAccess<'a> = &mut v;

我们同时拥有对(部分)inner 的共享和可变引用!

如果没有 Generic Associated Types，您的问题将无法完全解决.它们允许您通过生命周期参数化关联类型，使其能够表达“我想返回与 self 的生命周期相关的关联类型”:

#![feature(generic_associated_types)]

trait Access {
    type Item<'a>
    where
        Self: 'a;
    fn get<'a>(&'a self) -> Self::Item<'a>;
    // Or, with lifetime elision:
    // fn get(&self) -> Self::Item<'_>;
}

impl<'a> Access for IntAccess<'a> {
    type Item<'b> = &'b i32
    where
        'a: 'b;

    fn get<'b>(&'b self) -> Self::Item<'b> {
        &self.i
    }
}

Playground .

我们可以在稳定版上这样做吗？我们可以效仿。而不是实现 Access对于 IntAccess本身，我们将为对它的引用实现它!

trait Access {
    type Item;
    fn get(self) -> Self::Item;
}

impl<'a, 'b> Access for &'b IntAccess<'a> {
    type Item = &'b i32;
    fn get(self) -> &'b i32 {
        &self.i
    }
}

Playground

这并不总是有效，因此不能完全替代 GAT，但在这种情况下已经足够好了。