Expression vs statement in Rust - Quick Revision & Key Differences

Recall & Review

beginner

What is an expression in Rust?

An expression is a piece of code that evaluates to a value. For example, 5 + 3 is an expression that evaluates to 8.

beginner

What is a statement in Rust?

A statement is a piece of code that performs an action but does not return a value. For example, <code>let x = 5;</code> is a statement that declares a variable.

intermediate

Can an expression be used as a statement in Rust?

Yes, an expression can be used as a statement by adding a semicolon ;. This turns the expression into a statement that does not return a value.

intermediate

What happens if you omit the semicolon after an expression in Rust?

If you omit the semicolon, the expression returns a value. This is often used in functions to return a value without the return keyword.

beginner

Example: Is <code>let y = 10;</code> an expression or a statement?

It is a statement because it declares a variable and does not return a value.

Which of the following is an expression in Rust?

A fn main() {}

B let x = 5;

C 5 + 2

D println!("Hello");

5 + 2 is an expression because it evaluates to a value (7). The others are statements or function definitions.

What does adding a semicolon after an expression do in Rust?

A Turns it into a statement that does not return a value

B Makes it a function

C Causes a syntax error

D Returns the value of the expression

Adding a semicolon turns an expression into a statement, so it does not return a value.

Which of these is a statement?

A let x = 10;

B x * 2

C 3 + 4

D x - 1

let x = 10; is a statement because it declares a variable and does not return a value.

What will this Rust code return? fn example() -> i32 { 5 + 3 }

A 5

B Nothing, it's a statement

C Error because no semicolon

D 8

The expression 5 + 3 returns 8 because there is no semicolon, so it returns the value.

Is println!("Hi"); an expression or a statement?

A Expression

B Statement

C Both

D Neither

println!("Hi"); is a statement because it performs an action and does not return a value.

Explain the difference between an expression and a statement in Rust.

Think about whether the code returns a value or just does something.

Why does omitting a semicolon after an expression matter in Rust functions?

Consider how Rust functions return values without the return keyword.

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