Why does shadowing change the mutability of a variable in this code? - rust

Question

In thie following code,
fn main()
{
let mename : String = String::from("StealthyPanda");
println!("{mename}");
let mename = displayswithhere(mename);
println!("{mename}");
let mename = addshere(mename);
println!("{mename}");
}
fn displayswithhere(astring: String) -> String
{
println!("{astring} here!");
return astring;
}
fn addshere(mut astring : String) -> String
{
astring.push_str(" here!");
astring
}
Why isn't there an error after mename is shadowed and not declared as mutable when being assigned the value of displayswithhere(mename)? The code runs exactly as if the variable mename was mutable all along. I don't understand where the bug in the code, if any, is located.

Answer 1

When you shadow a variable, you create another one, distinct from the previous, but with the same name (that is just a coincidence).
The drawback is that you cannot simply refer to the former with its name any more because this names now refers to the latter.
On the example below, the functions fn_1() and fn_2() are very similar except that in fn_1() we still can refer directly to the original variable, but in fn_2() we have to find another way: we introduce a reference with a different name.
This is not related to mutability since the original variable keeps its original value all the way long.
On the other hand, fn_3() relies on mutability but we do not use let with the same name a second time, so the second assign operation is not an initialisation of a new variable but a real assign operation which will change the value of the original variable.
fn fn_1() {
println!("~~~~~~~~");
let my_var = 1;
println!("my_var: {}", my_var);
let my_other_var = 2; // creating another variable with a different name
println!("my_other_var: {}", my_other_var);
println!("my_var: {}", my_var);
}
fn fn_2() {
println!("~~~~~~~~");
let my_var = 1;
println!("my_var: {}", my_var);
let ref_to_my_var = &my_var;
let my_var = 2; // creating another variable with the same name (coincidence)
println!("my_var: {}", my_var);
println!("ref_to_my_var: {}", ref_to_my_var);
}
fn fn_3() {
println!("~~~~~~~~");
let mut my_var = 1;
println!("my_var: {}", my_var);
my_var = 2; // changing the origianl variable, which must be mutable
println!("my_var: {}", my_var);
}
fn main() {
fn_1();
fn_2();
fn_3();
}
/*
~~~~~~~~
my_var: 1
my_other_var: 2
my_var: 1
~~~~~~~~
my_var: 1
my_var: 2
ref_to_my_var: 1
~~~~~~~~
my_var: 1
my_var: 2
*/

Answer 2

You're saying "the variable mename", but there's three in your main function. You can convince yourself of that by running the following code:
#![allow(unused_variables)]
struct Foo(i32);
impl Foo {
fn new(v: i32) -> Foo {
println!("{v}");
Foo(v)
}
}
impl Drop for Foo {
fn drop(&mut self) {
println!("{}", self.0);
}
}
fn main() {
let foo = Foo::new(0);
let foo = Foo::new(1);
let foo = Foo::new(2);
println!("At this point, all three Foos are alive, each in its own variable");
}
Now you may ask, if I can just shadow a previous variable, what's the difference to just having it mutable? The difference should become apparent when your run this code:
fn main() {
let i = 0;
for _ in 0..2 {
println!("{i}");
let i = i + 1;
println!("{i}");
}
}