Shadowing Rust

Синтаксис let — это привязка (binding) к объекту на стеке. Время жизни объекта, определяется областью видимости.

{ // lifetime
    let x = 0;
    let y = &x; // reference to x = 0
    let x = 1;
    let z = &x; // reference to x = 1

    assert_eq!(*y, 0);
    assert_eq!(*z, 1);
    // destroy z, x = 1, y, x = 0
}

Типичный пример, где это может пригодиться.

let mut age = String::new();
io::stdin().read_line()?;
let age: Option<u32> = age.trim().parse().ok();

В — внимательность. Поправил пример.

let mut age = String::new();
io::stdin().read_line(&mut age)?;
let age: Option<u32> = age.trim().parse().ok();

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

Почему бы самому не проверить?

struct A(u32);

impl Drop for A {
    fn drop(&mut self) {
        println!("A({}) уничтожена", self.0);
    }
}

fn main() {
    let a = A(0);
    println!("A(0) создана");
    let a = A(1);
    println!("A(1) создана");
}

Результат

A(0) создана
A(1) создана
A(1) уничтожена
A(0) уничтожена

Переменные уничтожаются в конце блока в порядке обратном объявлению.

Кроме того, мне сложно представить как это использовать в реальном коде

Ну, например, let foo = tranform_foo(foo, ...). Так не требуется плодить имена для различных форм одного и того же.

кроме как let x = x + 1 в каких-нибудь циклах

Вот так как раз не получится делать. `let x` не меняет `x`.

Реальный пример, это когда ты читаешь от куда либо данные (например, из json по сети), а потом их преобразовываешь (например, строка в число). Это позволяет не создавать стопитьсоц переменных (например, 1 для json, 1 для строки, 1 для числа) ради данных которые логически едины, а просто затеняешь предыдущее состояние.

Реальный пример, это когда ты читаешь от куда либо данные (например, из json по сети), а потом их преобразовываешь (например, строка в число). Это позволяет не создавать стопитьсоц переменных (например, 1 для json, 1 для строки, 1 для числа) ради данных которые логически едины, а просто затеняешь предыдущее состояние

А можно просто написать композицию трёх функций, и ничего затенять не придётся

Кроме того, мне сложно представить как это использовать в реальном коде, кроме как let x = x + 1 в каких-нибудь циклах, но в расте из функциональщины достаточно отличных функций, потому вообще не могу представить чтобы в циклах надо было инкрементить переменные.

Ты в курсе про мутабельные переменные?

let mut x = 1;
x = x + 1;

А можно просто написать композицию трёх функций, и ничего затенять не придётся

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

А можно просто написать композицию трёх функций

А можно не писать. Большое количество однострочных функций, которые используются ровно один раз, не способствуют читабельности кода.

Если они правда однострочные, то и незачем их отдельно куда-то выносить (и как-то специально называть) - всё делается на месте, при помощи функциональщины.

А можно просто написать композицию трёх функций, и ничего затенять не придётся

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

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

всё делается на месте, при помощи функциональщины

А можно конкретный пример где это делает код проще и понятней? Только не на чисто функциональных ЯП, в которых писание императивного кода по определению причиняет боль.

А можно конкретный пример где это делает код проще и понятней? Только не на чисто функциональных ЯП

Если про Rust, то цепочки итераторов + лямбды. Пример кода здесь.
Даже завезли в язык специальный for_each ради единства стиля.
Попробуй переписать код, используя «затенение переменной», если хочешь.

Это всё отлично, но какое имеет отношение к

Реальный пример, это когда ты читаешь от куда либо данные (например, из json по сети), а потом их преобразовываешь (например, строка в число). Это позволяет не создавать стопитьсоц переменных (например, 1 для json, 1 для строки, 1 для числа) ради данных которые логически едины, а просто затеняешь предыдущее состояние

?

Это пример, когда многократное затенение преобразованного состояния заменяется многократной композицией функций. Ровно об этом мы и говорили. Если тебе нужно что-то другое, то уточняй.

Этот пример не имеет никакого отношения к обсуждаемой теме.

1. Утечки тут нет.

2. Удобно. Я очень часто использую.

А можно просто написать композицию трёх функций, и ничего затенять не придётся

Ну уж нет, библиотеки Rust позволяют не писать много кода и не плодить миллион функций, чему я очень рад.

Будь конкретнее.

Мы тут говорим про простые случаи вида

let x = 123;
let x: ДругойТип = сделать_что_то(x);
let x: ЕщёТип = сделать_что_то_ещё(x);
x

Мы тут говорим про простые случаи вида

let x = 123;
let x: ДругойТип = сделать_что_то(x);
let x: ЕщёТип = сделать_что_то_ещё(x);
x

Ок. Чем это лучше сделать_что_то_ещё(сделать_что_то(123))?

Гарантией влезания в экран и лучшей читабельностью для тех, кто читает слева направо и сверху вниз.

Проблема в лайфтамах. Может ругаться на то, что временный объект живёт слишком мало.

Ну и в diff'ах будет красивее.

1. Прямой порядок выполнения
2. Функция может возвращать или принимать несколько значений
3. Первоначально, x может быть результатом сопоставления с образцом.