Difference b/w Mutability and Shadowing

When it comes to modifying the variables, Rust has two options for you.

• Mutability

• Shadowing

Now let’s discuss them one by one and see what makes them different and useful.

Mutability

Mutability means that you’re allowed to change the value of a variable in place. By default every variable is immutable but if you want to make it mutable, you have to specifically put the mut keyword for it.

Once a value is bound to a name, you can’t change it until you make it mutable. Here is an example of it:

fn main() {
    let x = 10;
    println!("Before: {}", x);

    x = 20;
    println!("After: {}", x);
}

After running this code, you will get the following error:

 --> src/main.rs:5:5
  |
2 |     let x = 10;
  |         - first assignment to `x`
...
5 |     x = 20; 
  |     ^^^^^^ cannot assign twice to immutable variable
  |
help: consider making this binding mutable
  |
2 |     let mut x = 10;
  |         +++

As you can see you can’t assign multiple values to an immutable variable. The variable should be mutable to modified.

Now let’s modify it and see if it runs:

fn main() {
    let mut x = 10;
    println!("Before: {}", x);

    x = 20; // ✅ Allowed to be modified because x is mutable
    println!("After: {}", x);
}

This time, x is allowed to be modified because of the mut keyword that I put before the x variable.

Now let’s take a look at what is shadowing and how it is different from mutability.

Shadowing

Shadowing means declaring a new variable with the same name. We can shadow the variable’s name and repeat it using the let keyword.

Here is another point that you can also write a new variable with a different type.

Now let’s take an example of it:

fn main() {
    let x = 5;
    
    let x = x + 1;
    
    {
        let x = x * 2;
        
        println!("The value of x in the inner scope is: {x}");
    }
    
    println!("The value of x in the outer scope is: {x}");
}

This program first binds x with value 5. Then it creates a new variable x by adding 1 to it. This thing is done in the outer scope.

Now in the inner scope that is created with the curly brackets, the third let statement also shadows x and creates a new variable by multiplying the previous value by 2 to give x a value of 12.

When that scope is over, the inner shadowing ends and x returns a value of 6. Here is the output that we will get:

The value of x in the inner scope is: 12
The value of x in the outer scope is: 6

Now when to mut and shadow?

• Use mut when you need to update a variable’s value multiple times in a function.

• Use shadowing when you need to transform a value (like trimming a string or changing its type).

What’s next?

If you need any Rust guidance and are just curious about learning Rust then you can check out the YouTube playlist “Rust for Beginners“ where I have covered all of the basic concepts in a simple way for you to understand.

If you're interested to learn Rust then I have a 2-month mentorship program for you called Rust for Beginners that will help you build a solid foundation & build amazing projects. Book a FREE call.

Happy Coding!