Ниже — компактный набор практических приёмов (с короткими примерами), которыми обычно исправляют ошибки borrow checker, сохраняя безопасность и хорошую производительность. Выберите подходящий по контексту.
1) Укоротить время жизни заимствования (включить дополнительную область видимости)
- Проблема: вы держите `&mut` слишком долго.
- Решение: ограничить `{ ... }`, явно завершить заимствование.
Пример:
let mut v = vec![1, 2];
{
let x = &mut v[0];
*x += 1;
} // x выходит из области видимости
let y = &mut v[1];
2) Разделить заимствования на непересекающиеся области (slices)
- Используйте `split_at_mut` для двух непересекающихся частей:
let mut v = vec![0,1,2,3];
let (left, right) = v.split_at_mut(mid_index);
left[i] = ...;
right[j] = ...;
- Аналогично: `slice::split_first_mut`, `split_last_mut`.
3) Итераторы для мутабельного доступа
- `iter_mut()` даёт безопасные непересекающиеся `&mut` подряд:
for x in v.iter_mut() { *x += 1; }
4) Переместить значение на время изменений (take/replace)
- Для полей `Option` или ячеек структуры:
let mut s = Some(struct_value);
if let Some(mut v) = s.take() {
// работать с v как с владением
s = Some(v);
}
- Или `std::mem::replace(&mut slot, new)` / `std::mem::take(&mut slot)` — без аллокаций, быстро.
5) Переструктурировать код в функции (ре-борроw — reborrow)
- Вынести часть логики в отдельную функцию, чтобы временные `&mut` не пересекались:
fn update_part(a: &mut A) { ... }
update_part(&mut s.part1);
update_part(&mut s.part2);
6) Interior mutability (когда нужно разделяемое мутабельное состояние)
- Однопоточная: `RefCell` / `Cell` — быстрые, но с runtime-проверкой заимствований.
- Многопоточная: `Arc<Mutex>` / `Arc<RwLock>`.
- Примечание: `RefCell` обычно быстрее клонирования/аллок., но может паниковать при нарушении правил.
7) Использовать счётчики владения, если требуется множественный владелец
- `Rc` / `Arc` + `RefCell`/`Mutex` при необходимости общего доступа.
8) Не держать заимствования через `.await` и точки сохранения состояния (async)
- Нельзя удерживать `&mut` через `.await`. Решения:
- клонировать минимальные данные (cheap clone),
- переместить владение (take/replace),
- использовать `Arc<Mutex>` для совместного доступа.
9) Для доступа к разным полям struct — паттерн-распаковка по mutable-полям
- Можно писать:
let S { ref mut a, ref mut b } = s;
// a и b — независимые &mut (компилятор проверит)
10) Последний аргумент — unsafe только при доказанной необходимости
- Используйте raw-поинтеры и unsafe-функции, если уверен(а) в соблюдении aliasing/validity правил и нужен микрооптим; по возможности избегайте.
Рекомендации по приоритету (с учётом производительности и безопасности):
1. Разделить заимствования на непересекающиеся области (`split_at_mut`, распаковка полей).
2. Короткие области видимости / выделение в функции.
3. `take` / `replace` для получения владения без копирования.
4. `iter_mut()` для последовательной обработки.
5. `RefCell`/`Cell` для гибкости (следите за накладными расходами на runtime-проверки).
6. `Arc/Mutex` для многопоточности.
7. `unsafe` только как крайняя мера.
Если приложите конкретный фрагмент кода (ошибку и строку), дам точный рефакторинг и минимально-инвазивный пример.