Expression vs statement in Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to assign the value 5 to variable x using an expression.

Rust

let x = [1];

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

Aprint!(5)

Blet 5

Cx = 5

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'let 5' which is invalid syntax.

Trying to assign with 'x = 5' inside a let statement.

Using print! macro instead of a value.

The value 5 is an expression that can be assigned to x. The other options are invalid statements or syntax errors.

2fill in blank

medium

Complete the code to print the sum of 3 and 4 using an expression inside println! macro.

Rust

println!("{}", [1]);

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

A3 + 4

Blet 3 + 4

C3 plus 4

Dprintln!(3 + 4)

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to use 'let' inside println! which is a statement.

Writing '3 plus 4' which is not valid Rust syntax.

Calling println! inside println! macro.

The expression '3 + 4' calculates the sum and can be used inside println!. The other options are invalid syntax or misuse of macros.

3fill in blank

hard

Fix the error by replacing the blank with a valid expression that returns 10.

Rust

let y = [1];

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

Areturn 10

Blet 10

C10

Dprintln!(10)

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'let 10' which is invalid here.

Using 'return 10' outside a function.

Using 'println!' which returns unit type, not 10.

The expression '10' is a valid value to assign. 'let 10' is invalid syntax, 'return 10' is a statement used inside functions, and 'println!' is a macro that returns ().

4fill in blank

hard

Complete the code to create a block expression that returns 15.

Rust

let z = { { let a = 10; a {BLANK_2}} 5 };

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

A{

B+

C-

D(

Attempts:

3 left

💡 Hint

Common Mistakes

Using '(' instead of '{' for block start.

Using '-' which subtracts instead of adds.

Omitting the block braces.

The block expression starts with '{' and the expression 'a + 5' returns 15. Using '-' would give 5, and '(' is invalid here.

5fill in blank

hard

Fill both blanks to create a block expression that returns the uppercase of a string slice.

Rust

let s = "hello";
let result = { { s.{BLANK_2}}().{{BLANK_2}}() };

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

A{

Bto_uppercase

Cto_string

D(

Attempts:

3 left

💡 Hint

Common Mistakes

Using '(' instead of '{' for block start.

Mixing up method names or missing parentheses.

Not converting to String after uppercase.

The block starts with '{'. The method 'to_uppercase()' converts the string slice to uppercase, then 'to_string()' converts it to a String. Using '(' is invalid here.

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