Expression vs statement in Rust - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code snippet?

Consider the following Rust code. What will it print?

Rust

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

A 10

B 12

C 11

D Error: missing semicolon

💡 Hint

Remember that blocks in Rust can be expressions returning the last value without a semicolon.

The block assigns z = x + 1 which is 6, then returns z * 2 which is 12. This value is assigned to y.

🧠 Conceptual

intermediate

Which of these is a statement in Rust?

Identify which option is a statement rather than an expression.

A let x = 10;

B "hello".len()

C 5 + 3

D x * 2

💡 Hint

Statements perform actions but do not return values.

let x = 10; is a statement that declares a variable. The others are expressions that produce values.

🔧 Debug

advanced

Why does this Rust code fail to compile?

Examine the code and select the reason for the compilation error.

Rust

fn main() {
    let x = 5;
    let y = if x > 3 {
        x + 1;
    } else {
        x - 1
    };
    println!("{}", y);
}

A No error, prints 6

B Error: missing else branch

C Error: x is not mutable

D Error: mismatched types because if branches return () due to semicolon

💡 Hint

Check the effect of semicolons on expressions inside if blocks.

The semicolon after x + 1 turns that expression into a statement returning unit (). The else branch returns x - 1 (an integer), so the branches have mismatched types.

📝 Syntax

advanced

Which option correctly uses an expression to assign a value in Rust?

Choose the correct Rust code that assigns y using an expression block.

A let y = { let a = 3; a + 4; };

B let y = { let a = 3; println!("{}", a + 4) };

C let y = { let a = 3; a + 4 };

D let y = { let a = 3; return a + 4; };

💡 Hint

Remember that the last expression in a block without a semicolon is the block's value.

Option C returns a + 4 as the block's value. Option C has a semicolon making the block return unit (). Option C uses return inside a block which is invalid here. Option C returns unit because println! returns unit.

🚀 Application

expert

What is the value of variable z after running this Rust code?

Analyze the code and determine the final value of z.

Rust

fn main() {
    let x = 2;
    let y = {
        let a = x * 3;
        a + 1
    };
    let z = if y > 6 {
        y * 2
    } else {
        y / 2
    };
    println!("{}", z);
}

A 14

B 7

C 6

D Error: mismatched types

💡 Hint

Calculate step-by-step: block value, then if condition, then final assignment.

y is a + 1 where a = 2 * 3 = 6, so y = 7. Since y > 6 is true, z = y * 2 = 14.

Practice

1. In Rust, which of the following best describes an expression?

easy

A. It calculates a value and returns it.

B. It performs an action but does not return a value.

C. It is used only for declaring variables.

D. It is a comment explaining the code.

Solution

1. Step 1: Understand what an expression does

   An expression in Rust always produces a value when evaluated.

2. Step 2: Compare with statements

   Statements perform actions but do not return values, unlike expressions.

3. Final Answer:

   It calculates a value and returns it. -> Option A

4. Quick Check:

   Expression = returns value [OK]

Hint: Expressions always produce values; statements do not [OK]

Common Mistakes:

• Confusing statements with expressions
• Thinking expressions do not return values
• Assuming all code lines are statements

2. Which of the following is a valid Rust statement?

easy

A. let x = 5;

B. 5 + 3

C. x * 2

D. println!("Hello")

Solution

1. Step 1: Identify statements vs expressions

   Statements perform actions and often end with a semicolon, like variable declarations.

2. Step 2: Check each option

   let x = 5; declares a variable and ends with a semicolon, so it's a statement. Options A and C are expressions without semicolons. println!("Hello") is a macro call but without a semicolon, so it's an expression.

3. Final Answer:

   let x = 5; -> Option A

4. Quick Check:

   Statements end with semicolon [OK]

Hint: Statements usually end with semicolons [OK]

Common Mistakes:

• Missing semicolon for statements
• Confusing macro calls without semicolon as statements
• Thinking expressions are statements

3. What is the output of this Rust code?

fn main() {
    let x = 3;
    let y = {
        let z = x + 2;
        z * 2
    };
    println!("{}", y);
}

medium

A. 8

B. 10

C. 7

D. Compilation error

Solution

1. Step 1: Evaluate the inner block expression

   Inside the block, z = x + 2 = 3 + 2 = 5, then the block returns z * 2 = 5 * 2 = 10.

2. Step 2: Assign and print the value

   Variable y gets the value 10, which is printed by println!.

3. Final Answer:

   10 -> Option B

4. Quick Check:

   Block expression returns 10 [OK]

Hint: Blocks return last expression value without semicolon [OK]

Common Mistakes:

• Assuming block returns unit () due to semicolon confusion
• Miscomputing z or y values
• Thinking println! returns a value

4. Identify the error in this Rust code snippet:

fn main() {
    let x = 5;
    let y = if x > 3 {
        x + 1;
    } else {
        x - 1
    };
    println!("{}", y);
}

medium

A. Variable x is not initialized

B. Missing semicolon after if expression

C. The if block returns unit type, causing a type mismatch

D. println! macro is used incorrectly

Solution

1. Step 1: Analyze the if expression branches

   The if branch has x + 1; with a semicolon, making it a statement returning unit (). The else branch returns x - 1 without semicolon, an expression returning i32.

2. Step 2: Understand type mismatch

   Because branches return different types (unit vs i32), Rust reports a type mismatch error for y.

3. Final Answer:

   The if block returns unit type, causing a type mismatch -> Option C

4. Quick Check:

   If branches must return same type [OK]

Hint: Remove semicolon in if branch to return value [OK]

Common Mistakes:

• Adding semicolon after expressions in if branches
• Ignoring type mismatch errors
• Assuming println! causes error

5. You want to assign a variable result to the value of a block that adds 2 to n only if n is positive, otherwise returns 0. Which code correctly uses expressions and statements?

hard

A. let result = if n > 0 { n + 2 } else { 0 };

B. let result = if n > 0 { n + 2; } else { 0; };

C. let result = if n > 0 { n + 2 } else { println!("Zero") };

D. let result = { if n > 0 { n + 2 } else { 0 } };

Solution

1. Step 1: Check if expressions return values

   Options A and D both return values correctly. let result = if n > 0 { n + 2; } else { 0; }; has semicolons inside if branches, making them statements returning unit (). let result = if n > 0 { n + 2 } else { println!("Zero") };'s else branch calls println! which returns unit (), causing type mismatch.

2. Step 2: Compare A and D

   let result = if n > 0 { n + 2 } else { 0 }; assigns directly from if expression. let result = { if n > 0 { n + 2 } else { 0 } }; wraps the if expression inside a block, which is also an expression returning the if's value. Both are valid, but let result = { if n > 0 { n + 2 } else { 0 } }; explicitly shows block expression usage.

3. Final Answer:

   let result = { if n > 0 { n + 2 } else { 0 } }; -> Option D

4. Quick Check:

   Block expression returns if expression value [OK]

Hint: Use blocks or if expressions without semicolons for values [OK]

Common Mistakes:

• Adding semicolons inside if branches
• Mixing expressions with statements causing type errors
• Using println! where a value is expected