In Rust, what’s the difference between “shadowing” and “mutability”?

by

I believe the confusion is because you’re conflating names with storage.

fn main() {
    let x = 5; // x_0
    println!("The value of x is {}", x);
    let x = 6; // x_1
    println!("The value of x is {}", x);
}

In this example, there is one name (x), and two storage locations (x_0 and x_1). The second let is simply re-binding the name x to refer to storage location x_1. The x_0 storage location is entirely unaffected.

fn main() {
    let mut x = 5; // x_0
    println!("The value of x is {}", x);
    x = 6;
    println!("The value of x is {}", x);
}

In this example, there is one name (x), and one storage location (x_0). The x = 6 assignment is directly changing the bits of storage location x_0.

You might argue that these do the same thing. If so, you would be wrong:

fn main() {
    let x = 5; // x_0
    let y = &x; // y_0
    println!("The value of y is {}", y);
    let x = 6; // x_1
    println!("The value of y is {}", y);
}

This outputs:

The value of y is 5
The value of y is 5

This is because changing which storage location x refers to has absolutely no effect on the storage location x_0, which is what y_0 contains a pointer to. However,

fn main() {
    let mut x = 5; // x_0
    let y = &x; // y_0
    println!("The value of y is {}", y);
    x = 6;
    println!("The value of y is {}", y);
}

This fails to compile because you cannot mutate x_0 while it is borrowed.

Rust cares about protecting against unwanted mutation effects as observed through references. This doesn’t conflict with allowing shadowing, because you’re not changing values when you shadow, you’re just changing what a particular name means in a way that cannot be observed anywhere else. Shadowing is a strictly local change.

So yes, you absolutely can keep the value of x from being changed. What you can’t do is keep what the name x refers to from being changed. At most, you can use something like clippy to deny shadowing as a lint.

More Related Contents:

  1. What’s the difference between placing “mut” before a variable name and after the “:”?
  2. cannot borrow `self.x` as immutable because `*self` is also borrowed as mutable
  3. What is the difference between a constant and a static variable and which should I choose?
  4. How to get variable name?
  5. Creating or referencing variables dynamically in Sass
  6. Error if don’t check if {{object.field}} exists
  7. When should an Excel VBA variable be killed or set to Nothing?
  8. Mutably borrow one struct field while borrowing another in a closure
  9. Why are variables “i” and “j” used for counters?
  10. Which variable size to use (db, dw, dd) with x86 assembly?
  11. HiveQL: Using query results as variables
  12. Why is it possible to implement Read on an immutable reference to File?
  13. How to use struct self in member method closure
  14. setq and defvar in Lisp
  15. What is the difference between a member variable and a local variable?
  16. LessCss dynamic variables based on ancestor class
  17. Is it possible to create a multi-line string variable in a Makefile
  18. Powershell pass variable to start-job
  19. Determine variable names dynamically according to a string in Fortran
  20. Why there are two ways of declaring variables in Go, what’s the difference and which to use?
  21. Comparing IEEE floats and doubles for equality
  22. Why are variables “i” and “j” used for counters?
  23. How can I modify self in a closure called from a member function?
  24. What does immutable mean?
  25. Windows Batch files: what is variable expansion, and what does EnableDelayedExpansion mean?
  26. What is the difference between immutable and const variables in Rust?
  27. How to iterate through a Hashmap, print the key/value and remove the value in Rust?
  28. Set fact with dynamic key name in ansible
  29. How does the Rust compiler know `Cell` has internal mutability?
  30. When should I quote CMake variable references?

Leave a Comment