Variable shadowing in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of variable shadowing with different types

What is the output of this Rust code snippet?

Rust

fn main() {
    let x = 5;
    let x = "hello";
    println!("{}", x);
}

A "hello"

B 5

C Compilation error due to type mismatch

D Runtime error

💡 Hint

Think about how Rust allows variable shadowing with different types.

In Rust, you can shadow a variable with a new variable of a different type. The second 'x' shadows the first and holds the string "hello". So, printing 'x' outputs "hello".

❓ Predict Output

intermediate

Value of variable after shadowing in nested scope

What will be printed by this Rust program?

Rust

fn main() {
    let x = 10;
    {
        let x = x + 5;
        println!("{}", x);
    }
    println!("{}", x);
}

A 10\n10

B 10\n15

C 15\n15

D 15\n10

💡 Hint

Remember that shadowing inside a block does not affect the outer variable.

Inside the inner block, 'x' is shadowed and equals 15. Outside, the original 'x' remains 10. So the output is 15 then 10.

🔧 Debug

advanced

Why does this shadowing cause a compile error?

This Rust code does not compile. What is the reason?

Rust

fn main() {
    let mut x = 5;
    let x = x + 1;
    x += 2;
    println!("{}", x);
}

A Cannot mutate 'x' because it is shadowed as immutable

B Cannot add integer to a mutable variable

C Shadowing is not allowed with mutable variables

D Missing semicolon after 'let x = x + 1'

💡 Hint

Check the mutability of the shadowed variable.

The original 'x' is mutable, but the shadowed 'x' is immutable by default. Trying to mutate the shadowed 'x' causes a compile error.

🔧 Debug

advanced

Identify the compile error related to shadowing

Which option shows a compile error caused by incorrect variable shadowing in Rust?

A let x = 5; let x = x + 1;

B let mut x = 5; let x = x + 1; x += 2;

C let x = 5; let x: i32 = x + 1;

D let x = 5; let mut x = x + 1; x += 2;

💡 Hint

Check the mutability of the shadowed variable.

Option B declares the original 'x' as mutable, but shadows it immutably with 'let x = x + 1'. Trying to mutate the shadowed 'x' with 'x += 2' causes a compile error.

🚀 Application

expert

Predict the final value after multiple shadowings

Consider this Rust code. What is the final value printed?

Rust

fn main() {
    let x = 2;
    let x = x * 3;
    {
        let x = x - 1;
        let x = x * 2;
        println!("Inner: {}", x);
    }
    println!("Outer: {}", x);
}

A Inner: 10\nOuter: 5

B Inner: 4\nOuter: 6

C Inner: 10\nOuter: 6

D Inner: 4\nOuter: 5

💡 Hint

Track each shadowing step carefully.

Initially, x=2. Then shadowed to 6 (2*3). Inside the block, x is shadowed to 5 (6-1), then shadowed again to 10 (5*2). So inner print is 10. Outside the block, x remains 6.

Practice

1. What does variable shadowing in Rust allow you to do?

easy

A. Prevent variables from being changed after initialization

B. Create a global variable accessible everywhere

C. Reuse the same variable name to store a new value or type

D. Automatically convert variable types without explicit casting

Solution

1. Step 1: Understand variable shadowing concept

   Variable shadowing means declaring a new variable with the same name as an existing one, which replaces the old variable in the current scope.

2. Step 2: Identify what shadowing allows

   This lets you reuse the same name to update the value or even change the type without needing a new variable name.

3. Final Answer:

   Reuse the same variable name to store a new value or type -> Option C

4. Quick Check:

   Shadowing = reuse variable name [OK]

Hint: Shadowing means reusing variable names for new values [OK]

Common Mistakes:

• Thinking shadowing creates global variables
• Confusing shadowing with immutability
• Assuming shadowing changes variable type automatically

2. Which of the following Rust code snippets correctly demonstrates variable shadowing?

easy

A. let x = 5; let x = x + 1; println!("{}", x);

B. let x = 5; x = x + 1; println!("{}", x);

C. let mut x = 5; x = x + 1; println!("{}", x);

D. let x = 5; mut x = 6; println!("{}", x);

Solution

1. Step 1: Check for correct shadowing syntax

   Shadowing uses let again with the same variable name to create a new variable that hides the old one.

2. Step 2: Analyze each option

   let x = 5; let x = x + 1; println!("{}", x);: let x = 5; let x = x + 1; println!("{}", x); valid shadowing using previous value. let x = 5; x = x + 1; println!("{}", x);: let x = 5; x = x + 1; ... reassignment to immutable, compile error. let mut x = 5; x = x + 1; println!("{}", x);: let mut x = 5; x = x + 1; ... valid mutation but no shadowing (missing second let). let x = 5; mut x = 6; println!("{}", x);: let x = 5; mut x = 6; ... invalid syntax, mut requires let.

3. Final Answer:

   let x = 5; let x = x + 1; println!("{}", x); -> Option A

4. Quick Check:

   Shadowing requires let again [OK]

Hint: Shadowing always uses 'let' again with the same name [OK]

Common Mistakes:

• Trying to reassign immutable variables without 'mut'
• Confusing shadowing with mutable reassignment
• Using 'mut' incorrectly with shadowing

3. What will be the output of this Rust code?

let x = 10;
let x = x * 2;
let x = "Value: ".to_string() + &x.to_string();
println!("{}", x);

medium

A. 20

B. Value: x

C. Compilation error

D. Value: 20

Solution

1. Step 1: Follow variable shadowing and type changes

   First, x is 10 (integer). Then shadowed to 20 (integer). Then shadowed again to a String "Value: 20" by concatenating strings.

2. Step 2: Understand the final print output

   The last x is a String "Value: 20", so printing it outputs exactly that.

3. Final Answer:

   Value: 20 -> Option D

4. Quick Check:

   Shadowing can change type; final value is string [OK]

Hint: Shadowing can change variable type and value [OK]

Common Mistakes:

• Assuming variable type cannot change with shadowing
• Expecting numeric output instead of string
• Confusing variable name with literal output

4. Identify the error in this Rust code using variable shadowing:

let x = 5;
let x = x + 1;
let mut x = x * 2;
x = 10;
println!("{}", x);

medium

A. Cannot shadow a variable with 'mut' after immutable shadowing

B. No error; code runs and prints 10

C. Shadowing requires the same type, but types differ here

D. Cannot assign to 'x' because it is not mutable

Solution

1. Step 1: Analyze shadowing and mutability

   First x is immutable 5, then shadowed to 6 (immutable), then shadowed to mutable 12.

2. Step 2: Check assignment and print

   Since the last x is mutable, assigning x = 10; is valid. Printing outputs 10.

3. Final Answer:

   No error; code runs and prints 10 -> Option B

4. Quick Check:

   Shadowing can add mutability; assignment allowed [OK]

Hint: Shadowing can change mutability; last variable controls it [OK]

Common Mistakes:

• Thinking mutability cannot be added by shadowing
• Confusing shadowing with reassignment rules
• Assuming type must stay the same when shadowing

5. Given this Rust code, what is the final value of result?

let x = 3;
let x = x + 2;
{
    let x = x * 2;
    let x = "Number: ".to_string() + &x.to_string();
    println!("{}", x);
}
let result = x + 1;
println!("{}", result);

hard

A. 6

B. 7

C. Number: 10

D. Compilation error due to type mismatch

Solution

1. Step 1: Track shadowing in outer and inner scopes

   Outside the block, x is first 3, then shadowed to 5. Inside the block, x shadows to 10 (5*2), then to a String "Number: 10". This inner shadowing does not affect outer x.

2. Step 2: Calculate final result outside the block

   Outside, x remains 5, so result = x + 1 = 6. The print inside the block shows "Number: 10" but does not change outer x.

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Inner shadowing does not affect outer variable [OK]

Hint: Inner scope shadowing doesn't change outer variable [OK]

Common Mistakes:

• Assuming inner shadowing changes outer variable
• Confusing printed output with variable value
• Expecting type change to persist outside inner scope