假设以下设计的例子：
struct Board {
squares: Vec<i32>,
}
struct Point<'a> {
board: &'a Board,
x: i32,
y: i32,
}
impl<'a> Point<'a> {
pub fn neighbors(&self) -> impl Iterator<Item = Point<'a>> {
[(0, -1), (-1, 0), (1, 0), (1, 0)]
.iter().map(|(dx, dy)| Point {
board: self.board,
x: self.x + dx,
y: self.y + dy,
})
}
}
这不能编译，因为根据我的理解，在lambda中创建的点的生命周期是不正确的：
error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
--> src/main.rs:14:25
|
14 | .iter().map(|(dx, dy)| Point {
| _________________________^
15 | | board: self.board,
16 | | x: self.x + dx,
17 | | y: self.y + dy,
18 | | })
| |_____________^
|
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the method body at 12:5...
--> src/main.rs:12:5
|
12 | / pub fn neighbors(&self) -> impl Iterator<Item = Point<'a>> {
13 | | [(0, -1), (-1, 0), (1, 0), (1, 0)]
14 | | .iter().map(|(dx, dy)| Point {
15 | | board: self.board,
... |
18 | | })
19 | | }
| |_____^
= note: ...so that the types are compatible:
expected &&Point<'_>
found &&Point<'a>
note: but, the lifetime must be valid for the lifetime 'a as defined on the impl at 11:1...
--> src/main.rs:11:1
|
11 | impl<'a> Point<'a> {
| ^^^^^^^^^^^^^^^^^^
note: ...so that return value is valid for the call
--> src/main.rs:12:32
|
12 | pub fn neighbors(&self) -> impl Iterator<Item = Point<'a>> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
我有点迷失为什么会出现这种情况，因为看起来这里的生命有意义。 Point的生命周期是由Board的引用生命周期引起的。因此，Point<'a>引用了具有生命周期'a的电路板，因此它应该能够创建更多Point<'a>，因为它们的电路板引用具有相同的生命周期（'a ）。
但是，如果我删除lambda，它可以工作：
impl<'a> Point<'a> {
pub fn neighbors(&self) -> [Point<'a>; 4] {
[
Point { board: self.board, x: self.x , y: self.y - 1},
Point { board: self.board, x: self.x - 1, y: self.y },
Point { board: self.board, x: self.x + 1, y: self.y },
Point { board: self.board, x: self.x , y: self.y + 1},
]
}
}
所以，我怀疑问题在于lambda可能在生命周期'a结束后运行。但是，这是否意味着我不能懒得产生这些观点？
tl; dr如何让借用检查器满意的方法是懒惰地创建新的结构，其生命周期与创建它们的结构相关联？
答案 0 :(得分：6)
当你在一个方法中遇到这种问题时，一件好事就是为&self添加一个明确的生命周期：
pub fn neighbors(&'a self) -> impl Iterator<Item = Point<'a>> {
[(0, -1), (-1, 0), (1, 0), (1, 0)]
.iter().map(|(dx, dy)| Point {
board: self.board,
x: self.x + dx,
y: self.y + dy,
})
}
错误现在更好
error[E0373]: closure may outlive the current function, but it borrows `self`, which is owned by the current function
--> src/main.rs:14:30
|
14 | .iter().map(|(dx, dy)| Point {
| ^^^^^^^^^^ may outlive borrowed value `self`
15 | board: self.board,
| ---- `self` is borrowed here
help: to force the closure to take ownership of `self` (and any other referenced variables), use the `move` keyword
|
14 | .iter().map(move |(dx, dy)| Point {
| ^^^^^^^^^^^^^^^
然后，您只需要根据编译器的建议添加move关键字，并告诉它您不会再次使用&'a self。
请注意，self的生命周期不得与Point的生命周期相同。最好使用此签名：
fn neighbors<'b>(&'b self) -> impl 'b + Iterator<Item = Point<'a>>
答案 1 :(得分：3)
现有的答案（Shepmaster，Boiethios）都允许迭代器返回的Point比迭代器本身更长。但是，应该可以通过将Point的内容移动到其中来构建迭代器，该迭代器甚至比原始Point更长。此版本保留原始功能签名：
fn neighbors(&self) -> impl Iterator<Item = Point<'a>> {
let Point { board, x, y } = *self;
[(0, -1), (-1, 0), (1, 0), (1, 0)]
.iter().map(move |(dx, dy)| Point {
board: board,
x: x + dx,
y: y + dy,
})
}
将*self的内容复制到移动到闭包中的局部变量使得闭包 - 因此返回的迭代器 - 不再包含对self的任何引用。
您可以使用此版本执行某些操作，否则无法完成此操作（playground）：
let mut p = Point {
board: &b,
x: 10,
y: 12,
};
for n in p.neighbors() {
p = n;
}
一个潜在的警告是，如果Point包含非常大或非Copy的数据，而这些数据无法或不应该被移入关闭，这就不会工作。在这种情况下，您应该使用其他解决方案：
fn neighbors<'b>(&'b self) -> impl 'b + Iterator<Item = Point<'a>>
答案 2 :(得分：2)
我会为self分配一个与Board的生命周期不同的生命周期：
impl<'b> Point<'b> {
fn neighbors<'a>(&'a self) -> impl Iterator<Item = Point<'b>> + 'a {
[(0, -1), (-1, 0), (1, 0), (1, 0)]
.iter().map(move |(dx, dy)| Point {
board: self.board,
x: self.x + dx,
y: self.y + dy,
})
}
}
这还需要将闭包标记为move以将&Self值移动到闭包中，以便闭包仍然可以访问board，x和{{1}当它是先进的。由于可以复制不可变引用，因此不会阻止调用者执行任何操作。
没有单独的生命周期，从迭代器返回的y的生命周期被人为地限制为生成它们的Point的生命周期。例如，此代码在生命周期统一时失败，但在它们不同时起作用：
Point另见：