Краткий ответ

Для этого используют std::mem::replace или, если поле имеет тип Option<T>, обычно Option::take. Они перемещают старое значение наружу, одновременно записывая на его место новое значение, поэтому заимствованная структура не остаётся частично инициализированной.

Обычный прямой перенос поля через &mut запрещён: изменяемая ссылка даёт исключительный доступ к объекту, но не передаёт право оставить его без значения.

Исторический контекст

Модель владения Rust должна предотвращать использование освобождённых или неинициализированных данных без сборщика мусора. Поэтому компилятор контролирует не только чтение и запись, но и перемещение значения из места, которым программа владеет не напрямую.

Заимствованное значение должно оставаться корректным на протяжении всего заимствования. Механизмы replace, take и swap позволяют безопасно менять содержимое таких мест, сохраняя инвариант полной инициализации.

Постановка проблемы

Изменяемая ссылка позволяет изменить поле структуры, но не позволяет просто забрать из него значение, оставив поле пустым. Для типа T понятия «пустое значение» обычно нет: после перемещения поле нельзя считать обычным доступным T.

Если бы такое перемещение разрешалось, последующий код мог бы прочитать уже перемещённое поле, а автоматическое освобождение структуры могло бы попытаться освободить отсутствующее значение. Rust запрещает эту ситуацию ещё на этапе компиляции.

Подробное решение

std::mem::replace принимает изменяемую ссылку на место и новое значение. Функция возвращает старое значение, а в исходное место записывает новое; старое значение не уничтожается автоматически, потому что передаётся вызывающему коду.

struct State {
    current: String,
}

fn take_current(state: &mut State) -> String {
    std::mem::replace(&mut state.current, String::from("idle"))
}

fn main() {
    let mut state = State { current: String::from("busy") };
    let old = take_current(&mut state);
    assert_eq!(old, "busy");
    assert_eq!(state.current, "idle");
}

Вызов получает &mut state.current, поэтому доступ к полю эксклюзивен. Но функция сразу оставляет в этом месте новое корректное значение, и структура остаётся полностью валидной.

std::mem::take является сокращением для случая, когда у типа есть Default: оно заменяет значение на T::default(). Для Option<T> часто применяют take, который заменяет Some(value) на None и возвращает прежнее содержимое.

std::mem::swap подходит, когда нужно обменять значения двух доступных мест. В отличие от replace, он не создаёт новое значение и не возвращает старое отдельно.

Компромисс состоит в том, что вызывающий код должен предоставить значение-замену. Если подходящего значения нет, структуру часто проектируют с полем Option<T>: состояние None явно представляет временное отсутствие ресурса. Клонирование старого значения тоже возможно, но оно может быть дорогим и не всегда семантически корректным.

Эти операции не отменяют правил заимствования: нельзя одновременно иметь несовместимые ссылки, а заменяемое место должно быть доступно через действительную изменяемую ссылку. Для данных, находящихся под Pin, произвольная замена дополнительно ограничивается правилами неподвижности; наличие &mut само по себе не означает, что значение можно переместить в памяти.

Ситуация из практики

Представим состояние соединения, где обработчик получает &mut ConnectionState, но должен забрать текущий буфер для передачи в другой компонент и сразу установить новый пустой буфер.

Вариант с клонированием прост, однако копирует все данные и может создавать значительные задержки. Попытка прямого перемещения поля не компилируется, поскольку поле принадлежит заимствованной структуре.

Можно хранить буфер как Option<Buffer> и использовать take: это наглядно показывает, что буфер временно изъят, но требует обработки состояния None. Если после изъятия всегда должен существовать новый буфер, предпочтительнее mem::replace: он передаёт старый буфер без копирования и сразу поддерживает инвариант валидного состояния.

Результат — владение буфером переходит вызывающему коду, структура остаётся полностью инициализированной, а лишнего клонирования нет.

Что кандидаты часто упускают

Почему нельзя просто присвоить полю новое значение и получить старое через отдельное выражение?

Присваивание новому значению уничтожает старое значение на месте, если оно не было предварительно перемещено. Чтобы вернуть старое значение вызывающему коду, нужна операция, которая контролируемо извлекает его и одновременно заполняет место заменой. Именно это гарантирует replace; порядок обычных выражений сам по себе такого контракта не создаёт.
Чем mem::replace отличается от mem::take с точки зрения требований к типу?

replace принимает явно переданное новое значение и поэтому работает с любым типом T. take подставляет T::default(), поэтому требует реализации Default и возвращает старое значение. take удобен для временного очищения поля, но выбранное значение по умолчанию должно быть корректным для дальнейшей работы структуры.
Почему Option<T> часто используют для временного извлечения ресурса?

Option<T> предоставляет явное безопасное состояние отсутствия значения: после take в поле находится None, а прежний T передан вызывающему коду. Это позволяет извлекать ресурс через изменяемую ссылку без неинициализированной памяти. Недостаток — каждый последующий доступ должен учитывать None, а инвариант «ресурс всегда присутствует» приходится проверять или восстанавливать отдельно.