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

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

fn main() {
    let value = 10;
    let value = value.to_string();
    println!("{value}");

    let mut count = 1;
    count = 2;
}

Во втором случае count остаётся тем же связыванием типа i32. В первом создаётся новое связывание value типа String; прежнее значение не изменяется, а старое имя становится недоступным в этой точке.

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

Затенение поддерживает распространённый стиль последовательного преобразования значения без введения искусственных имён вроде parsed_value, validated_value и normalized_value. Это особенно удобно, когда каждый этап обработки имеет тот же логический смысл, но другой тип или дополнительные инварианты.

Отдельно существующее присваивание необходимо для изменения состояния объекта после его создания. Такое разделение помогает отличать преобразование данных от мутации состояния и позволяет компилятору проверять оба сценария разными правилами.

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

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

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

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

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

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

Присваивание работает с уже найденным связыванием. Для него требуется mut, а новое значение должно соответствовать типу этого связывания с учётом разрешённых преобразований контекста; автоматического превращения одного произвольного типа в другой не происходит.

Важно различать доступность имени и время жизни значения. После затенения прежнее имя нельзя использовать напрямую в месте, где видимо новое имя, но прежнее значение не обязано немедленно уничтожаться только из-за затенения. Если оно не является Copy, его владение всё ещё учитывается правилами Rust.

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

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

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

Разные имена делают все этапы одновременно доступными и могут упростить отладку, но увеличивают количество имён и риск случайно использовать значение не того этапа. Затенение делает поток преобразования компактнее и не позволяет случайно обратиться к старому имени после следующего объявления, однако при сложной логике может скрыть наличие нескольких живущих значений.

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

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

Дополнительный вопрос: можно ли затенить неизменяемое связывание без mut?

Да. Затенение создаёт новое связывание, поэтому оно не является изменением старого. Модификатор mut нужен только тогда, когда существующему связыванию присваивают новое значение или иным способом изменяют данные через него.
Дополнительный вопрос: обязательно ли старое значение уничтожается сразу после затенения?

Нет. Затенение скрывает старое имя, но не является операцией присваивания и само по себе не означает немедленный вызов drop. Время уничтожения определяется областью действия и правилами времени жизни значения; поэтому два значения, последовательно связанные с одним именем, могут одновременно существовать до выхода из области.
Дополнительный вопрос: почему присваивание не позволяет сменить тип переменной?

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