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.