读取可变引用与不可变引用具有不同的生命周期语义

特征类型对其通用参数是不变的。

考虑这个例子：

struct Test<'a, F: Fn(&'a i32)> {
    i: &'a i32,
    f: F,
}

fn main() {
    let i = 1i32;
    let t = Test { i: &i, f: |&_| {} };

    {
        let j = 2i32;
        (t.f)(&j);
    }

    println!("{:?}", t.i);
}

这将给出错误：

error[E0597]: `j` does not live long enough
  --> src/main.rs:12:15
   |
12 |         (t.f)(&j);
   |               ^^ borrowed value does not live long enough
13 |     }
   |     - `j` dropped here while still borrowed
14 | 
15 |     println!("{:?}", t.i);
   |                      --- borrow later used here

如您所见，该类型Test<'a ...并没有统一到更短的生命周期，j因为Test包含一个 trait impl 类型N（静态调度）。因此，它将在 上保持不变'a，因此'a无法缩短。但j不为'a，因此错误。

转到您的问题，让我们看一下您的代码的最小版本：

struct Wrapper<'r, R, N>
where
    N: Fn(&'r R),
{
    r: &'r mut R,
    n: N,
}

impl<'r, R, N> Wrapper<'r, R, N>
where
    N: Fn(&'r R),
{
    fn myderef(&self) {
        (self.n)(self.r)
    }
}

这将给出相同的错误：

error[E0312]: lifetime of reference outlives lifetime of borrowed content...
  --> src/lib.rs:14:18
   |
14 |         (self.n)(self.r)
   |                  ^^^^^^
   |
note: ...the reference is valid for the lifetime 'r as defined on the impl at 9:6...
  --> src/lib.rs:9:6
   |
9  | impl<'r, R, N> Wrapper<'r, R, N>
   |      ^^
note: ...but the borrowed content is only valid for the anonymous lifetime #1 defined on the method body at 13:5
  --> src/lib.rs:13:5
   |
13 | /     fn myderef(&self) {
14 | |         (self.n)(self.r)
15 | |     }
   | |_____^

这里到底发生了什么？&selfwith lifes 将是 type&'shorter_lifetime Wrapper<'r, R, N>而不是&'shorter_lifetime Wrapper<'shorter_lifetime, R, N>。'r不会被缩短为'shorter_lifetime因为Wrapper它的通用生命周期参数是不变的，'r因为N.

现在我们知道参数类型到底&self是什么，让我们看看myderef(). 特征类型N（静态分派）使用self.r. 但是self.r是一个可变引用，当传递给(self.r)(). 所以现在你有一个可变引用，它在另一个引用后面（self是一个引用），它需要存活'r（N需要它的输入参数与'r定义一样具有生命周期），因此&self也需要存活'r. 但是&self的生命周期是'shorter_lifetime，因此是错误的。

换句话说，如果你有&'a & 'b mut T（'a和之间没有子类型关系'b）作为函数的输入参数，并且编译器允许你重新借用内部引用并返回它，那么就违反了借用规则，因为&mut T已经是后面有参考。外部引用“拥有”内部引用，主要是因为内部引用是可变的，并且函数需要保证外部引用至少在重新借用内部（可变）引用时保留，否则在函数调用之后将是可变引用的不止一个所有者。

例如，以下代码将无法编译：

fn test<'a, 'b> (i:&'a &'b mut i32) -> &'b i32 {
    &**i
}

但是这个会：

fn test<'a:'b, 'b> (i:&'a &'b mut i32) -> &'b i32 {
    &**i
}

因为有一个保证'a至少可以存活多久'b。

如果内部引用是不可变的，那么前者也会编译，因为您可以有多个不可变引用。没有外部引用“拥有”内部引用的概念。

为了编译最小版本，我们必须告诉编译器它&self也适用于'r. 要么删除的输入参数'r上的硬约束N（生命周期省略）。

在您的示例中，deref()不允许您&self根据Deref的定义在 上指定生命周期。如果删除'ronN的输入参数的硬约束，它将编译