Compilation and execution flow in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust program?

Consider this Rust code snippet. What will it print when run?

Rust

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

A 8

B 6

C 9

D Compile error

💡 Hint

Remember that inner blocks can shadow outer variables temporarily.

The inner block defines a new x as 3, then adds 1, so y is 4. The outer x is 5. So the sum is 5 + 4 = 9.

Wait, option C says 8, option C says 9. Let's check carefully.

Inner block: let x = 3; x + 1 evaluates to 4.

Outer x is 5.

Sum: 5 + 4 = 9.

Option C is 9, option C is 8. So correct answer is A.

❓ Predict Output

intermediate

What error does this Rust code produce?

What error will this Rust code cause when compiled?

Rust

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

A Prints 20

B Compile error: cannot assign to `x` because it is borrowed

C Prints 10

D Runtime panic: borrow error

💡 Hint

Rust enforces borrowing rules at compile time.

The variable x is borrowed immutably by y. Then x is assigned a new value while the borrow is active, which is not allowed. This causes a compile-time error.

🧠 Conceptual

advanced

Order of compilation steps in Rust

Which of the following correctly lists the main steps Rust compiler performs in order?

A 1, 2, 3, 4

B 2, 1, 3, 4

C 1, 3, 2, 4

D 3, 1, 2, 4

💡 Hint

Think about how source code is processed from raw text to machine code.

Rust compiler first breaks code into tokens (lexical analysis), then builds a syntax tree (parsing), then checks borrow rules (borrow checking), and finally generates machine code (code generation).

🔧 Debug

advanced

Why does this Rust program panic at runtime?

Examine this Rust code. Why does it panic when run?

Rust

fn main() {
    let v = vec![1, 2, 3];
    let x = v[3];
    println!("{}", x);
}

A Prints 0

B Compile error: index out of bounds

C Prints 3

D Index out of bounds panic at runtime

💡 Hint

Check the vector length and the index used.

The vector has elements at indices 0, 1, and 2. Accessing index 3 is out of bounds, causing a runtime panic.

🚀 Application

expert

What is the output of this Rust async program?

Consider this Rust async code using tokio. What will it print?

Rust

#[tokio::main]
async fn main() {
    let handle = tokio::spawn(async {
        5 + 3
    });
    let result = handle.await.unwrap();
    println!("{}", result);
}

A 8

B Compile error: missing runtime

C Runtime panic: unwrap on None

D 0

💡 Hint

Think about what tokio::spawn returns and how await works.

The spawned task returns 8. Awaiting the handle unwraps the result and prints 8.

Practice

1. What is the first step when running a Rust program?

easy

A. Directly run the Rust source file without compiling

B. Compile the code using rustc to create an executable

C. Write the output to a file before compiling

D. Use an interpreter to execute the Rust code line by line

Solution

1. Step 1: Understand Rust's execution model

   Rust is a compiled language, so the source code must be compiled first.

2. Step 2: Identify the compilation tool

   The rustc compiler converts Rust code into an executable file.

3. Final Answer:

   Compile the code using rustc to create an executable -> Option B

4. Quick Check:

   Rust code is compiled first [OK]

Hint: Rust code must be compiled before running [OK]

Common Mistakes:

• Thinking Rust runs like a script without compiling
• Confusing Rust with interpreted languages
• Trying to run source code directly

2. Which command correctly compiles a Rust file named main.rs?

easy

A. run rustc main.rs

B. compile main.rs

C. rustc main.rs

D. cargo run main.rs

Solution

1. Step 1: Recall Rust compilation command

   The Rust compiler command is rustc followed by the filename.

2. Step 2: Check each option

   rustc main.rs matches the correct syntax: rustc main.rs.

3. Final Answer:

   rustc main.rs -> Option C

4. Quick Check:

   Use rustc filename.rs to compile [OK]

Hint: Use 'rustc' followed by filename to compile [OK]

Common Mistakes:

• Adding extra words like 'run' before rustc
• Using 'compile' instead of 'rustc'
• Confusing cargo commands with rustc

3. What will be the output when running this Rust program?

fn main() {
    println!("Hello, Rust!");
}

medium

A. Hello, Rust!

B. println!("Hello, Rust!");

C. Error: missing semicolon

D. No output

Solution

1. Step 1: Understand the println! macro

   This macro prints the string inside quotes to the console with a newline.

2. Step 2: Check the code correctness

   The code is syntactically correct and will print the message.

3. Final Answer:

   Hello, Rust! -> Option A

4. Quick Check:

   println! outputs the string [OK]

Hint: println! prints text to console with newline [OK]

Common Mistakes:

• Thinking println! prints the code itself
• Expecting no output without return statement
• Confusing macro syntax with function

4. Identify the error in this Rust code snippet:

fn main() {
    println!("Hello, world!")
}

medium

A. Missing closing parenthesis for println! macro

B. No error, code runs fine

C. Incorrect function name

D. Missing semicolon after println! macro

Solution

1. Step 1: Check statement termination syntax

   Rust requires semicolons to terminate expression statements like println! macro calls.

2. Step 2: Locate the missing semicolon

   The println! call is missing the terminating semicolon before the closing brace.

3. Final Answer:

   Missing semicolon after println! macro -> Option D

4. Quick Check:

   Expression statements require semicolon [OK]

Hint: Rust expression statements require a trailing semicolon [OK]

Common Mistakes:

• Thinking it's a parenthesis mismatch
• Confusing macros with block expressions
• Believing no semicolon needed before closing brace

5. You have two Rust files: lib.rs and main.rs. You want to compile main.rs which uses functions from lib.rs. What is the correct compilation and execution flow?

hard

A. Compile lib.rs into a library, then compile main.rs linking the library, then run the executable

B. Run main.rs directly without compiling lib.rs

C. Compile only main.rs, Rust automatically compiles lib.rs

D. Combine both files manually into one file before compiling

Solution

1. Step 1: Understand Rust's multi-file compilation

   The rustc compiler automatically handles referenced modules like lib.rs when compiling main.rs.

2. Step 2: Single command suffices

   With mod lib; in main.rs, rustc main.rs compiles both files and produces the executable.

3. Final Answer:

   Compile lib.rs into a library, then compile main.rs linking the library, then run the executable -> Option A

4. Quick Check:

   rustc main.rs compiles dependencies automatically [OK]

Hint: rustc compiles referenced modules automatically [OK]

Common Mistakes:

• Trying to run source files without compiling dependencies
• Assuming Rust compiles dependencies automatically at runtime
• Manually merging files instead of compiling separately