Время жизни для метода, возвращающего итератор структур с таким же временем жизни

Когда у вас есть такая проблема в методе, неплохо было бы добавить явное время жизни к &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>>

Оба существующих ответа (Shepmaster, Boiethios) позволяют Points, возвращаемым итератором, пережить сам итератор. Однако должна существовать возможность построить итератор, который даже переживает первоначальный 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.

Вот кое-что, что вы можете сделать с этой версией, что невозможно сделать иначе (игровая площадка):

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>>

Я бы назначил время жизни 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 и y, когда оно продвинуто. Поскольку неизменяемые ссылки могут быть скопированы, это не помешает вызывающей стороне что-либо делать.

Без отдельных времен жизни время жизни Point, возвращаемых итератором, искусственно ограничивается временем жизни Point, который их сгенерировал. Например, этот код не работает, когда времена жизни объединены, но работает, когда они различны:

fn example<'b>(board: &'b Board) {
    let _a = {
        let inner = Point { board, x: 0, y: 0 };
        let mut n = inner.neighbors();
        n.next().unwrap()
    };
}

Смотрите также:

• Когда полезно определять несколько времен жизни в структуре?