Borrowing и ссылкиBorrowing and references

Borrowing — способ получить временный доступ к значению через ссылку, не забирая владение (см. ownership.html — читать сначала, это обязательный предварительный материал). &T — разделяемая (неизменяемая) ссылка: таких ссылок на одни данные может существовать сколько угодно одновременно, и через них нельзя мутировать данные. &mut T — эксклюзивная (изменяемая) ссылка: в любой момент времени существует максимум одна, и пока она жива, никакая другая ссылка (ни &T, ни другая &mut T) на те же данные существовать не может. Это и есть правило "aliasing xor mutability" (алиасинг исключает мутируемость): либо сколько угодно читателей, либо ровно один писатель — никогда одновременно оба.Borrowing is a way to get temporary access to a value through a reference without taking ownership (see ownership.html — read it first, it's a mandatory prerequisite). &T is a shared (immutable) reference: any number of them can exist simultaneously for the same data, and none of them can mutate it. &mut T is an exclusive (mutable) reference: at most one can exist at any given time, and while it's alive no other reference (neither &T nor another &mut T) to the same data may exist. This is the "aliasing xor mutability" rule: either any number of readers, or exactly one writer — never both at once.

fn print_len(v: &Vec<i32>) {
    println!("len = {}", v.len());  // только чтение через разделяемую ссылку// read-only access through a shared reference
}

fn main() {
    let data = vec![1, 2, 3];
    print_len(&data);   // заимствование — data остаётся владельцем// borrowed — data remains the owner
    println!("{:?}", data);  // OK: data всё ещё доступна после вызова// OK: data is still accessible after the call
}

Ownership без borrowing был бы практически неюзабельным — вот что решает этот механизм:Ownership without borrowing would be practically unusable — here's what this mechanism solves:

Попытка создать &mut T, пока жива &T на те же данные, — ошибка компиляции:Attempting to create a &mut T while a &T to the same data is alive is a compile error:

let mut v = vec![1, 2, 3];
let r1 = &v;              // разделяемая ссылка создана// shared reference created
let r2 = &mut v;          // ОШИБКА: нельзя создать &mut, пока жива &// ERROR: cannot create &mut while a & is alive
println!("{:?}", r1);
println!("{:?}", r2);

Последовательные, не перекрывающиеся во времени заимствования компилируются без проблем — заимствования не обязаны никогда не пересекаться в коде, важно лишь, чтобы их фактические времена жизни не перекрывались:Sequential, non-overlapping borrows compile without any issue — borrows don't need to avoid overlapping in the source, only their actual live ranges must not overlap:

let mut v = vec![1, 2, 3];
{
    let r1 = &v;
    println!("{:?}", r1);  // r1 используется в последний раз здесь// r1's last use is here
}
let r2 = &mut v;          // OK: r1 уже не жив// OK: r1 is no longer alive
r2.push(4);

С Rust 2018 borrow checker использует так называемые "non-lexical lifetimes" (NLL) — он отслеживает фактическое последнее использование заимствования, а не его лексическую область видимости до конца блока. Это значит, что &T, которая больше не используется дальше по коду, не блокирует последующую &mut T, даже если формально обе "видны" до конца блока — фигурные скобки из примера выше на самом деле не нужны:Since Rust 2018, the borrow checker uses so-called "non-lexical lifetimes" (NLL) — it tracks a borrow's actual last use, not its lexical scope to the end of the block. This means a &T that's no longer used later in the code doesn't block a subsequent &mut T, even though both are lexically "in scope" until the end of the block — the braces in the example above aren't actually required:

let mut v = vec![1, 2, 3];
let r1 = &v;
println!("{:?}", r1);      // последнее использование r1 — здесь// r1's last use is here
let r2 = &mut v;          // OK благодаря NLL, хотя r1 лексически ещё "в области видимости"// OK thanks to NLL, even though r1 is lexically still "in scope"
r2.push(4);

• The Rust Book — References and Borrowing
• The Rustonomicon — Splitting Borrows