rust - Const 闭包数组采用对 Rust 中具有生命周期参数的结构的可变引用

Question

我在 Rust 项目中有以下场景:

struct Foo<'a> {
    stuff: &'a i32,
}

因此我告诉编译器我的 Foo struct 持有对某物的引用，我必须给它一个生命周期才能使它正常工作。

现在，我声明:

type FooFunc<'a> = &'a dyn Fn(&'a mut Foo<'a>) -> bool;

const funcs: [FooFunc; 4] = [
    &|f| { *f.stuff = 0; false },
    &|f| { *f.stuff = 1; true },
    &|f| { *f.stuff = 2; true },
    &|f| { *f.stuff = 3; true },
];

并尝试从 Foo 的“方法”中的常量数组调用闭包:

impl<'a> Foo<'a> {
    fn bar(&mut self, i: usize) -> bool {
        funcs[i](self)
    }
}

关于生命周期的推理，这应该没问题，因为 self引用Foo struct 有生命周期 'a (这肯定不会比 'static 长寿，那是闭包的生命周期)所以闭包应该能够接收 self作为参数没有任何问题。

借用检查器有点同意这一点，但仍然报告一个我不明白的错误:

error[E0308]: mismatched types
 --> src/main.rs:7:18
  |
7 |         funcs[i](self)
  |                  ^^^^ lifetime mismatch
  |
  = note: expected type `&'static mut Foo<'static>`
             found type `&'static mut Foo<'a>`
note: the lifetime 'a as defined on the impl at 5:6...
 --> src/main.rs:5:6
  |
5 | impl<'a> Foo<'a> {
  |      ^^
  = note: ...does not necessarily outlive the static lifetime

error[E0312]: lifetime of reference outlives lifetime of borrowed content...
 --> src/main.rs:7:18
  |
7 |         funcs[i](self)
  |                  ^^^^
  |
  = note: ...the reference is valid for the static lifetime...
note: ...but the borrowed content is only valid for the anonymous lifetime #1 defined on the method body at 6:5
 --> src/main.rs:6:5
  |
6 | /     fn bar(&mut self, i: usize) -> bool {
7 | |         funcs[i](self)
8 | |     }
  | |_____^

它告诉我(在 note 标签中)the lifetime 'a as defined on the impl at 5:6 does not necessarily outlive the static lifetime那the reference is valid for the static lifetime but the borrowed content is only valid for the anonymous lifetime #1 defined on the method body at 6:5 .虽然给出此类错误消息的编译器很棒，但我仍然不明白问题出在哪里。

谈论第二个note (这是(试图)解释问题的那个)，我不明白借用的内容是 const 数组还是 self 引用，但无论哪种情况:

• 如果“借用的内容”是 const 数组，为什么即使已将与函数体匹配的匿名生命周期分配给它也会出现问题？闭包只需对作为参数传递的引用进行操作，并通过转移返回值的所有权返回，而不是通过返回具有可能导致问题的奇怪生命周期的引用。

• 如果“借用的内容”是自引用，那为什么会出现问题呢？好了，自引用没有了'a ，但它是另一个(我们称之为 'b )，它“包含”在 'a 中，因此不应该比'static长寿，对吧？

当然，我在这里遗漏了一些东西，我们将不胜感激。

注意:这篇文章中的所有代码只是我试图实现的“架构”的精简版本——当然，您在示例代码中看到的逻辑可以很容易地实现以一种简单的方式，但这不是我需要的。我想在我的结构上做一个操作表(因此想法使元素闭包接受 &mut 引用)并从我的结构的“方法”运行这些操作。实际项目中的实际类型改为[Option<[FooFunc<'a>; 6]>; 256] ，所以我们正在谈论一个相当大的二维“表”，我想用 match 来实现它会变得非常不愉快。语句，特别是考虑到我重用 FooFunc非常频繁。

https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=17034fe41c74d65d7a296ae812f19945

Answer 1

type FooFunc<'a> = &'a dyn Fn(&'a mut Foo<'a>) -> bool; 行没有说“FooFunc 是任何生命周期对闭包的引用，闭包引用任何生命周期(相同生命周期的 Foo)”。相反，它表示“A FooFunc<'a> 是一个具有特定生命周期 'a 的闭包引用，该闭包引用了该特定生命周期 'a(指向具有相同特定生命周期 Foo 的 'a ), 每次调用闭包时都是一样的。”

此外，当您在项目声明 ([FooFunc; 4]) 中省略生命周期时，它会被推断为 'static。 (这是因为类型本身不能超过它们的类型参数，但项目必须是 'static ，所以唯一有效的生命周期参数也是 'static 。)所以 funcs 是一个只接受 &'static mut Foo<'static> 的闭包引用数组。

您可能想要的是 type FooFunc<'r> = &'r for<'a, 'b> dyn Fn(&'a mut Foo<'b>) -> bool; ，尽管由于其他地方的可变性问题这仍然失败。这就是说“FooFunc<'r> 是生命周期 'r 对闭包的引用，闭包接受任何生命周期对 Foo s 的引用，任何 生命周期(后一个生命周期隐含地比第一个生命周期长)生命周期)。” 'r 仍将被推断为 'static，但这没关系，因为这就是你所拥有的。