Владение и заимствование

В цикле ниже items используется после обхода. Какой механизм Rust делает переменную недоступной после цикла?

fn main() {
    let items = vec![String::from("a"), String::from("b")];

    for item in items {
        println!("{item}");
    }

    println!("{}", items.len());
}

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

Верно ли, что ограничение T: 'static означает обязательное существование значения до завершения программы?

Перед вами функция, принимающая callback, который возвращает заимствование из своего аргумента. Объясните, какую гарантию здесь даёт for<'a>:

fn identity<'a>(value: &'a str) -> &'a str {
    value
}

fn apply(
    callback: impl for<'a> Fn(&'a str) -> &'a str,
    text: &str,
) -> &str {
    callback(text)
}

fn main() {
    let text = String::from("ready");
    println!("{}", apply(identity, &text));
}

Разберите последствия: что делает Rust с прежним значением владеющей переменной при присваивании ей нового значения?

Можно ли безопасно получить два изменяемых заимствования из разных частей одного среза, если граница разделения вычисляется во время выполнения?

Допустимо ли в безопасном Rust намеренно не освобождать значение, и чем это отличается от нарушения памяти?

Что перемещается при присваивании переменной типа &mut T другой переменной, и почему исходное имя после этого недоступно?

В каких случаях Rust продлевает время жизни временного значения, на которое взяли ссылку?

Что мешает типу, реализующему Drop, одновременно реализовать Copy?

Что определяет, захватит ли замыкание переменную по ссылке или переместит её?

Что происходит с локальными владельцами при панике во время раскрутки стека?

Практическая ситуация: почему замыканию, передаваемому в новый поток, часто требуется захватить значение по владению, а не по заимствованию?

Каким механизмом RefCell<T> позволяет изменять данные через неизменяемую ссылку, не нарушая правил безопасной памяти Rust?

Представьте, что в Vec есть ссылка на элемент: по какой причине Rust не позволяет изменить размер этого вектора, пока ссылка используется?

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

Как Rust определяет, что одновременные заимствования двух разных полей структуры безопасны?

Каким образом заменить поле структуры через изменяемую ссылку, не перемещая его наружу?

Сравните владение через Rc<T> с обычным владением: как определяется момент освобождения общего значения?

При присваивании неизменяемой ссылки другой переменной что именно копируется и почему исходное значение не дублируется?