Scope of variables in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a variable inside the main function.

Rust

fn main() {
    let [1] = 5;
    println!("Value: {}", x);
}

Drag options to blanks, or click blank then click option'

A5

Bx

Clet

Dmain

Attempts:

3 left

💡 Hint

Common Mistakes

Using a number instead of a variable name.

Trying to use a keyword like 'let' as the variable name.

The variable name x is declared with let inside main. This makes it accessible within the function.

2fill in blank

medium

Complete the code to print the variable declared inside the block.

Rust

fn main() {
    {
        let y = 10;
        println!("[1]: {}", y);
    }
}

Drag options to blanks, or click blank then click option'

Ay

Bz

Cx

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name not declared in the block.

Trying to print a variable declared outside the block.

The variable y is declared inside the block and can be used there. So we print y.

3fill in blank

hard

Complete the code to attempt accessing the variable outside its scope and observe the error.

Rust

fn main() {
    {
        let z = 15;
    }
    println!("Value: {}", [1]);
}

Drag options to blanks, or click blank then click option'

Az

B15

Cvalue

Dlet

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to use z outside its block (this is expected to error).

Using a literal number where a variable is expected.

The variable z is out of scope outside the block, so using it causes a compile error: 'z not found in this scope'.

4fill in blank

hard

Fill both blanks to declare and use a variable inside a nested block.

Rust

fn main() {
    let [1] = 20;
    {
        println!("[2] inside block: {}", [1]);
    }
}

Drag options to blanks, or click blank then click option'

Anum

Bvalue

Dnumber

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for declaration and print label.

Using a variable name not declared.

The variable num is declared outside the nested block and is accessible inside it. The print label matches for clarity.

5fill in blank

hard

Fill all three blanks to declare a variable, declare another based on it, and print both values.

Rust

fn main() {
    let [1] = 5;
    let [2] = [1] + 10;
    println!("Original: {}, Second: {}", [1], [2]);
}

Drag options to blanks, or click blank then click option'

Ax

By

Dz

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same variable name for both declarations.

Mixing up variable names in the print statement.

The variable x is declared first (=5). Then y is declared as x + 10 (=15). Both are in scope for printing.

Practice

1. What does the scope of a variable in Rust determine?

easy

A. Where the variable can be accessed or used

B. The type of the variable

C. The value stored in the variable

D. The memory size of the variable

Solution

1. Step 1: Understand the meaning of scope

   Scope means the part of the code where a variable is valid and can be used.

2. Step 2: Identify what scope controls

   Scope controls access to the variable, not its type, value, or memory size.

3. Final Answer:

   Where the variable can be accessed or used -> Option A

4. Quick Check:

   Scope = access area [OK]

Hint: Scope means where you can use the variable [OK]

Common Mistakes:

• Confusing scope with variable type
• Thinking scope controls variable value
• Mixing scope with memory size

2. Which of the following is the correct way to declare a variable inside a block in Rust?

easy

A. var x = 5;

B. let x = 5;

C. int x = 5;

D. declare x = 5;

Solution

1. Step 1: Recall Rust variable declaration syntax

   Rust uses let keyword to declare variables.

2. Step 2: Check each option

   Only let x = 5; is valid Rust syntax; others are from other languages or invalid.

3. Final Answer:

   let x = 5; -> Option B

4. Quick Check:

   Rust variables start with let [OK]

Hint: Rust variables start with let keyword [OK]

Common Mistakes:

• Using var instead of let
• Using type declarations like int
• Using declare keyword

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

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

medium

A. 10\n10

B. 20\n20

C. 10\n20

D. 20\n10

Solution

1. Step 1: Identify variable shadowing inside inner block

   Inside the inner block, x is redefined as 20, shadowing outer x.

2. Step 2: Trace the print statements

   First print shows inner x = 20; second print shows outer x = 10.

3. Final Answer:

   20 10 -> Option D

4. Quick Check:

   Inner shadow = 20, outer original = 10 [OK]

Hint: Inner block shadows outer variable [OK]

Common Mistakes:

• Ignoring shadowing and printing outer value twice
• Assuming inner variable changes outer variable
• Confusing print order

4. Identify the error in this Rust code snippet:

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

medium

A. Variable y is used outside its scope

B. Missing semicolon after let y = 5

C. println! macro is misspelled

D. No error, code runs fine

Solution

1. Step 1: Check where y is declared and used

   Variable y is declared inside inner block and goes out of scope after block ends.

2. Step 2: Analyze usage of y outside block

   Using y in println! outside block causes error because y is not visible there.

3. Final Answer:

   Variable y is used outside its scope -> Option A

4. Quick Check:

   Use inside scope only [OK]

Hint: Variables vanish outside their block scope [OK]

Common Mistakes:

• Thinking semicolon is missing
• Assuming println! is wrong
• Ignoring variable scope rules

5. Consider this Rust code:

fn main() {
    let mut count = 0;
    for i in 0..3 {
        let count = count + i;
        println!("{}", count);
    }
    println!("Final count: {}", count);
}

What will be the output and why?

hard

A. 0\n1\n2\nFinal count: 6

B. 0\n1\n2\nFinal count: 2

C. 0\n1\n2\nFinal count: 0

D. Compilation error due to variable shadowing

Solution

1. Step 1: Understand variable shadowing inside the loop

   Inside the loop, count is shadowed by a new variable count equal to outer count plus i. Outer count remains unchanged.

2. Step 2: Trace loop iterations and prints

   Iterations: i=0 -> inner count=0, print 0; i=1 -> inner count=1, print 1; i=2 -> inner count=2, print 2. Outer count stays 0.

3. Step 3: Final print shows outer count

   After loop, outer count is still 0, so prints "Final count: 0".

4. Final Answer:

   0 1 2 Final count: 0 -> Option C

5. Quick Check:

   Shadowing hides outer count, outer unchanged [OK]

Hint: Shadowing inside loop doesn't change outer variable [OK]

Common Mistakes:

• Assuming outer count changes inside loop
• Confusing shadowing with mutation
• Expecting sum accumulation in outer count