Rust Brain Teasers/

...

/

Puzzle 13: Explanation

Puzzle 13: Explanation

Let’s learn about how variable scoping works in Rust.

We'll cover the following...

Test it out

Hit “Run” to see the code’s output.

Press + to interact
fn display_neutron_flow(polarity: isize) {
    println!(
        "Neutron Flow is {}",
        if polarity < 0 { "reversed"} else { "normal" }
    );
}
fn main() {
    let polarity = 1;
    {
        let polarity = polarity - 2;
        display_neutron_flow(polarity);
    }
    display_neutron_flow(polarity);
}

Explanation

The code creates a variable named polarity. It then creates another variable with the same name and a different value. Reusing variable names is known as shadowing and is a controversial topic in Rust development houses. Rust explicitly permits the creation of shadowed variables. However, unlike many other programming languages, we won’t see a compiler warning when using this feature.

Let’s take a step back and look at what let polarity = 1; really does. With this code, the compiler performs the following functions:

  1. Sets aside an area of memory sized to fit the data’s type that holds the data—usually on the stack.
  2. Writes the value 1 to the new area of memory.
  3. Updates its list of “variable bindings” for the current scope to indicate that polarity refers to this area of memory.

The compiler does not store the name polarity because naming variables is a convenience for us as programmers. It’s much easier to remember a name than a memory address. (Debug information stores the name and association. That’s how our debugger can show us variable information.)

The compiler performs these steps with every variable assignment. If we call:

let polarity = 2;
and
let polarity = 2;

within the same scope, the first variable remains in existence, but its variable binding is replaced with no way to access it.

The following diagram illustrates how that happens:

The code takes advantage of scope ...