Почему мы повторно объявляем изменяемость при обращении к изменяемой переменной?

Question

Я читаю главу 2 Язык программирования Rust и что-то, чего я не понимаю, привлекло мое внимание:

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin().read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {}", guess);
}

О кодеВ строке 5 он объявляет изменяемую переменную с let mut guess = String::new(), но на следующей строке аргумент для read_line() также имеет ключевое слово mut.

Если переменная была определена как изменяемая в первую очередь,тогда почему мы снова используем mut вместо того, чтобы просто использовать ссылку, подобную этой:

io::stdin().read_line(&guess).expect("Failed to read line");

Если тип определен для переменной, то когда мы используем ссылку, не должен ли тип (mut) существуют по умолчанию?

Answer 1

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

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

Таким образом, чтобы создать ссылку на что-то изменяемое, нужно явно использовать &mut.Это правило, компилятор знает, что значение может быть видоизменено, и может сделать это за вас, но Rust просит вас написать его явно, это так просто.

Answer 2

TL; DR: Это проектное решение.Компилятор Rust может разумно определить, необходима ли изменчивость или нет;однако для читателя это может быть неочевидно.

---

Длинная история

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

foo.call(bar);

только определение call сообщит вам, передан ли bar по значению, константной или изменяемой ссылке.В результате, Руководство по стилю Google печально известно тем, что оно обязывает передавать по указателю любой изменяемый аргумент, чтобы различать на стороне вызова , может ли переменная быть измененаили нет.

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

Существует противоречие между явностью и краткостью, поэтому явность не всегда предпочтительна, ночасто это так.

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

Answer 3

Поскольку у вас может быть либо неизменяемая ссылка на изменяемую переменную, либо изменяемая ссылка на изменяемую переменную.Ключевое слово mut выбирает тип ссылки, которую вы хотите создать.

let mut foo = 1;
example1(&foo);     // May not modify `foo`
example2(&mut foo); // May modify `foo`

См. Также:

• Как передать ссылку на изменяемые данныев Rust?
• Какая разница между размещением «mut» перед именем переменной и после «:»?