Expression vs statement in Rust - Trade-offs & Expert Analysis

Overview - Expression vs statement

What is it?

In Rust, an expression is a piece of code that produces a value, like a math calculation or a function call. A statement is a piece of code that performs an action but does not return a value, like creating a variable or calling a function without using its result. Expressions can be part of statements, but statements cannot be part of expressions. Understanding the difference helps you write clear and correct Rust code.

Why it matters

Knowing the difference between expressions and statements helps you understand how Rust runs your code and how to write code that works as expected. Without this, you might get errors or write code that doesn't do what you want. For example, Rust requires blocks to end with an expression if you want to return a value, so mixing these up can cause bugs or confusion.

Where it fits

Before learning this, you should know basic Rust syntax like variables, functions, and blocks. After this, you can learn about control flow, ownership, and how Rust evaluates code to produce results.

Mental Model

Core Idea

An expression always produces a value, while a statement performs an action but does not produce a value.

Think of it like...

Think of expressions as ingredients that create a dish (value), and statements as the cooking steps that prepare or arrange those ingredients but don’t produce a dish by themselves.

Block of code
┌─────────────────────────────┐
│ Statement: does something    │
│ ┌─────────────────────────┐ │
│ │ Expression: produces val│ │
│ └─────────────────────────┘ │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

What is an expression in Rust

Concept: Introduce expressions as code that produces a value.

In Rust, an expression is any code that results in a value. Examples include numbers like 5, math like 3 + 4, or calling a function that returns something. Expressions can be used anywhere a value is needed.

Result

Expressions produce values you can use or store.

Understanding expressions is key because Rust treats almost everything as an expression, making code concise and flexible.

2

Foundation

What is a statement in Rust

Concept: Introduce statements as code that performs actions but does not produce values.

Statements do things like create variables or call functions without using their return values. For example, let x = 5; is a statement that creates a variable but does not itself produce a value. Statements end with a semicolon.

Result

Statements perform actions but do not produce values.

Knowing statements helps you understand how Rust organizes code that changes state or controls flow.

3

Intermediate

Expressions inside statements

🤔Before reading on: do you think every statement contains an expression? Commit to your answer.

Concept: Statements often contain expressions inside them.

For example, let x = 5 + 3; is a statement that contains the expression 5 + 3. The expression produces 8, which is then assigned to x. The statement itself does not produce a value, but the expression inside does.

Result

Statements can include expressions, but the statement itself does not return a value.

Understanding this helps you see how Rust builds complex actions from smaller value-producing parts.

4

Intermediate

Blocks as expressions

🤔Before reading on: do you think a block of code with multiple statements can be an expression? Commit to your answer.

Concept: Blocks of code enclosed in braces can be expressions if they end with an expression without a semicolon.

In Rust, a block like { let x = 3; x + 1 } is an expression because it ends with the expression x + 1 without a semicolon. This block produces the value 4. If the last line had a semicolon, the block would be a statement and produce no value.

Result

Blocks can be expressions if they end with an expression, allowing complex value calculations.

Knowing this lets you write concise code that returns values from multiple steps.

5

Intermediate

Semicolon changes expression to statement

🤔Before reading on: does adding a semicolon to an expression change its behavior? Commit to your answer.

Concept: Adding a semicolon after an expression turns it into a statement that does not return a value.

For example, 5 + 6 is an expression producing 11. But 5 + 6; is a statement that performs the calculation but discards the result. This is why semicolons matter in Rust syntax.

Result

Semicolons control whether code produces a value or just performs an action.

Understanding this prevents common bugs where values are unintentionally discarded.

6

Advanced

Expressions in control flow

🤔Before reading on: do you think if and match can be expressions in Rust? Commit to your answer.

Concept: Control flow constructs like if and match are expressions that produce values.

In Rust, you can write let x = if condition { 5 } else { 10 }; Here, if is an expression that returns a value depending on the condition. This allows powerful and concise code.

Result

Control flow expressions let you assign values based on conditions cleanly.

Knowing control flow as expressions unlocks Rust’s expressive power and reduces boilerplate.

7

Expert

Expression vs statement in Rust’s type system

🤔Before reading on: do you think statements have types in Rust? Commit to your answer.

Concept: Expressions have types and produce values; statements do not have types and do not produce values.

Rust’s compiler uses types to check expressions. Since statements do not produce values, they have no type. This distinction helps Rust catch errors early and optimize code. For example, you cannot assign a statement to a variable because it has no type.

Result

Understanding typing differences helps write correct and efficient Rust code.

Knowing this prevents confusion about what can be used where and why some code causes type errors.

Under the Hood

Rust’s compiler treats expressions as code that returns a value and has a type. Statements are instructions that perform actions but do not return values or have types. When compiling, Rust evaluates expressions to produce values that can be stored or used, while statements control flow or side effects. The semicolon is a syntax marker that tells the compiler to treat an expression as a statement by discarding its value.

Why designed this way?

Rust was designed to be safe and expressive. Treating almost everything as expressions allows concise code and powerful constructs like if and match returning values. The clear distinction between expressions and statements helps the compiler enforce correctness and optimize code. Other languages often blur this line, causing confusion or bugs.

Code flow
┌───────────────┐
│ Source code   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Parser        │
│ - Identifies  │
│   expressions │
│ - Identifies  │
│   statements  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Compiler      │
│ - Evaluates   │
│   expressions │
│ - Executes    │
│   statements  │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does adding a semicolon to an expression keep its value? Commit yes or no.

Common Belief: Adding a semicolon after an expression does not change its value or behavior.

Reality: Adding a semicolon turns the expression into a statement that discards the value.

Why it matters: This causes bugs where expected values are lost, leading to unexpected behavior or compiler errors.

Quick: Can statements be used anywhere expressions are expected? Commit yes or no.

Common Belief: Statements can be used wherever expressions are used because they are similar.

Reality: Statements do not produce values and cannot be used where expressions are required.

Why it matters: Trying to use statements as expressions causes compiler errors and confusion.

Quick: Are all blocks in Rust statements? Commit yes or no.

Common Belief: All blocks of code enclosed in braces are statements.

Reality: Blocks can be expressions if they end with an expression without a semicolon.

Why it matters: Misunderstanding this limits the ability to write concise, value-returning code blocks.

Quick: Do statements have types in Rust? Commit yes or no.

Common Belief: Statements have types just like expressions.

Reality: Statements do not have types because they do not produce values.

Why it matters: Confusing this leads to type errors and misunderstanding of Rust’s type system.

Expert Zone

1

Some expressions have the unit type () which looks like no value but is still a value, blurring the line between expressions and statements.

2

Macros in Rust can produce statements or expressions depending on how they are written, making their behavior subtle.

3

The distinction affects how Rust handles control flow and error handling, especially with the ? operator that works on expressions.

When NOT to use

Avoid treating statements as expressions; for example, do not try to assign a let statement to a variable. Instead, use expressions or blocks that return values. In some cases, imperative code with statements is clearer than complex nested expressions.

Production Patterns

Rust developers use expression blocks to write concise functions that return values without explicit return statements. They also use control flow expressions to handle errors and conditions cleanly. Statements are used for setup, side effects, and organizing code flow.

Connections

Functional programming

Expression-oriented programming builds on the idea that code is mostly expressions returning values.

Understanding Rust’s expression vs statement distinction helps grasp functional programming concepts where expressions dominate.

Mathematics (equations vs instructions)

Expressions correspond to equations producing values; statements correspond to instructions performing actions.

Seeing code as math-like expressions versus action-like statements clarifies how programs compute results.

Cooking recipes

Statements are like cooking steps; expressions are like ingredients or mixtures that produce a dish.

This connection helps understand how code builds results step-by-step versus producing values.

Common Pitfalls

#1 Losing value by adding a semicolon unintentionally

Wrong approach:

let x = 5 + 6; // This is a statement, value discarded

Correct approach:

let x = 5 + 6; // Actually correct here because let expects expression
let y = { 5 + 6 }; // Block expression producing value

Root cause:

Misunderstanding that semicolon turns expression into statement discarding value.

#2 Trying to assign a statement to a variable

Wrong approach:

let x = let y = 5; // Error: statement used as expression

Correct approach:

let y = 5;
let x = y; // Correct: x assigned expression value

Root cause:

Confusing statements with expressions and their roles.

#3 Ending a block with a semicolon when a value is needed

Wrong approach:

let x = {
let y = 3;
y + 1;
}; // Block is statement, no value returned

Correct approach:

let x = {
let y = 3;
y + 1
}; // Block is expression, returns 4

Root cause:

Not knowing that semicolon suppresses value return from block.

Key Takeaways

Expressions produce values and have types; statements perform actions and do not produce values.

Adding a semicolon after an expression turns it into a statement that discards the value.

Blocks can be expressions if they end with an expression without a semicolon, allowing complex value computations.

Control flow constructs like if and match are expressions in Rust, enabling concise and powerful code.

Understanding the difference between expressions and statements is essential for writing correct, idiomatic Rust code.

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