Question

我有一个特性，我想为所有实现std::ops::Index的类型实现它。这段代码有效（正如我所料）：

use std::ops::Index;
use std::fmt::Display;


trait Foo {
    fn foo(&self, i: usize) -> &Display;
}

impl<C> Foo for C 
where
    C: Index<usize>,
    C::Output: Display + Sized,
{
    fn foo(&self, i: usize) -> &Display {
        &self[i]
    }
}

（Playground）

然而，一旦我向我的特质引入了一个通用参数，我就会遇到奇怪的生命周期错误。这是代码（Playground）：

trait Foo<T> {
    fn foo(&self, i: T) -> &Display;
}

impl<C, T> Foo<T> for C 
where
    C: Index<T>,
    C::Output: Display + Sized,
{
    fn foo(&self, i: T) -> &Display {
        &self[i]
    }
}

奇怪的错误（显然它是一个错误，在略有不同的版本中重复了三次）：

  error[E0311]: the associated type `<C as std::ops::Index<T>>::Output` may not live long enough
  --> src/main.rs:15:9
   |
15 |         &self[i]
   |         ^^^^^^^^
   |
   = help: consider adding an explicit lifetime bound for `<C as std::ops::Index<T>>::Output`
note: the associated type `<C as std::ops::Index<T>>::Output` must be valid for the anonymous lifetime #1 defined on the method body at 14:5...
  --> src/main.rs:14:5
   |
14 | /     fn foo(&self, i: T) -> &Display {
15 | |         &self[i]
16 | |     }
   | |_____^
note: ...so that the type `<C as std::ops::Index<T>>::Output` is not borrowed for too long
  --> src/main.rs:15:9
   |
15 |         &self[i]
   |         ^^^^^^^^

error[E0311]: the associated type `<C as std::ops::Index<T>>::Output` may not live long enough
  --> src/main.rs:15:9
   |
15 |         &self[i]
   |         ^^^^^^^^
   |
   = help: consider adding an explicit lifetime bound for `<C as std::ops::Index<T>>::Output`
note: the associated type `<C as std::ops::Index<T>>::Output` must be valid for the anonymous lifetime #1 defined on the method body at 14:5...
  --> src/main.rs:14:5
   |
14 | /     fn foo(&self, i: T) -> &Display {
15 | |         &self[i]
16 | |     }
   | |_____^
note: ...so that the type `<C as std::ops::Index<T>>::Output` will meet its required lifetime bounds
  --> src/main.rs:15:9
   |
15 |         &self[i]
   |         ^^^^^^^^

error[E0311]: the associated type `<C as std::ops::Index<T>>::Output` may not live long enough
  --> src/main.rs:15:10
   |
15 |         &self[i]
   |          ^^^^^^^
   |
   = help: consider adding an explicit lifetime bound for `<C as std::ops::Index<T>>::Output`
note: the associated type `<C as std::ops::Index<T>>::Output` must be valid for the anonymous lifetime #1 defined on the method body at 14:5...
  --> src/main.rs:14:5
   |
14 | /     fn foo(&self, i: T) -> &Display {
15 | |         &self[i]
16 | |     }
   | |_____^
note: ...so that the reference type `&<C as std::ops::Index<T>>::Output` does not outlive the data it points at
  --> src/main.rs:15:10
   |
15 |         &self[i]
   |          ^^^^^^^

我根本不理解这个错误。特别是因为错误会讨论C::Output的生命周期（据我所知） nothing 与附加参数K有关。

有趣的是，不返回特征对象&Display，而是将返回的关联类型添加到Foo，会导致生命周期错误消失（Playground）。但是，这对我来说不是一个解决方案。

这个错误是什么意思？是否有意义？这是编译器错误吗？参数K与C::Output的生命周期有什么关系？

Answer 1

这很有意义，并且不是编译器错误，但它有点不方便。

完整解释

可以为Index<T>类型实施C，以使C::Output的类型必须比 internal 的生命周期更长T。这是一个愚蠢的例子：

struct IntRef<'a>(&'a i32);

impl<'a, 'b: 'a> Index<IntRef<'a>> for IntRef<'b> {
    type Output = IntRef<'a>;
    fn index(&self, _: IntRef<'a>) -> &Self::Output {
        self
    }
}

一揽子impl会尝试为Foo<IntRef<'a>>实施IntRef<'b>，这是不健全的。要了解原因，请查看此非编译示例：

let b = 2i32; // 'b begins here:
let b_ref = IntRef(&b);
let o: &Display;  // a reference that outlives 'a but not 'b
{
    let a = 1i32; // 'a begins here:
    let a_ref = IntRef(&a);

    o = &b_ref[a_ref]; // <-- this errors: "a doesn't live long enough"
                       //     which is correct!
    o = b_ref.foo(a_ref); // <-- this wouldn't error, because the returned
                          //     value is `&'x (Display + 'x)` where 'x is
                          //     the lifetime of `b_ref`
}
println!("{:?}", o);

o = &b_ref[a_ref];将无法编译，因为Index已实施，b_ref[a_ref]不能超过a_ref。但是o = b_ref.foo(a_ref) 必须编译，因为Foo<T>::foo的定义......

fn foo(&self, i: T) -> &Display                   // what you wrote
fn foo<'a>(&'a self, i: T) -> &'a ('a + Display)  // what the compiler inferred

...强制在&self的生命周期内，输出的生命周期仅取决于（请参阅this question）。编译器拒绝Foo的全面实现，因为如果允许，您可以使用它来放大＆＃34;放大＆＃34;像上面例子中的a_ref一样。

（我无法想出让IntRef变得实用的方法，但事实仍然是你可以做到这一点。可能，内部可变性，足够聪明如果允许的话，这个人可能会引入不健全。）

解决方案0：快速＆amp;脏

只要求T永远不会包含任何（非'static）引用，您的工作就完成了。

impl<C, T> Foo<T> for C
where
    T: 'static,
    C: Index<T>,
    C::Output: Display + Sized,

对于Index特征的最常见用法可能就是这种情况，但如果您希望能够实施Foo<&T>（这不是不合理的话），那么您会想要尝试一些限制性较小的东西。

另一种可能性是C::Output需要'static，但这又比必要时更加保守。

解决方案1：最佳方式

让我们回到Foo::foo：

的贬低

fn foo<'a>(&'a self, i: T) -> &'a ('a + Display)

注意'a中的两个&'a ('a + Display)。虽然它们是相同的，但它们代表不同的东西：返回引用的（最大）生命周期，以及被引用的东西中包含的任何引用的（最大）生命周期。

在Index中，我们正在使用它来实现Foo，返回引用的生命周期始终与&self的借位相关联。但是Self::Output可能包含具有不同（可能更短）生命周期的其他引用，这是整个问题。所以我们真正想写的是......

fn foo(&self, i: T) -> &('a + Display)            // what you write
fn foo<'b>(&'b self, i: T) -> &'b ('a + Display)  // what the compiler infers

...将&self的生命周期从Self::Output内部的任何生命周期中解耦。

当然现在的问题是'a在任何地方的特征中都没有定义，所以我们必须将它作为参数添加：

trait Foo<'a, T> {
    fn foo(&self, i: T) -> &('a + Display);
}

现在你可以告诉Rust C::Output必须比'a更长久才能申请impl，并且一切都会好（playground）：

impl<'a, C, T> Foo<'a, T> for C
where
    C: Index<T>,
    C::Output: 'a + Display + Sized,
{
    fn foo(&self, i: T) -> &('a + Display) {
        &self[i]
    }
}

解决方案2：将方法绑定在方法

上

解决方案1要求您将生命周期参数添加到Foo，这可能是不合需要的。另一种可能性是向where添加foo条款，该条款要求T比返回的&Display更长。

trait Foo<T> {
    fn foo<'a>(&'a self, i: T) -> &'a Display where T: 'a;
}

它有点笨拙，但实际上它可以让你将需求转移到功能而不是特质本身。缺点是此还通过坚持返回值永远不会超过Foo中的任何引用来排除T的某些实现。

添加不相关的泛型参数会触发奇怪的生命周期错误

1 个答案:

完整解释

解决方案0：快速＆amp;脏

解决方案1：最佳方式

解决方案2：将方法绑定在方法