Program structure in Rust - Mini Project: Build & Apply

Understanding Program Structure in Rust

📖 Scenario: You are learning how to write a simple Rust program. Rust programs start with a main function where the code runs. You will create a basic program that prints a greeting message.

🎯 Goal: Build a Rust program with a main function that prints Hello, Rust! to the screen.

📋 What You'll Learn

Create a main function

Use println! macro to print text

Print exactly Hello, Rust!

💡 Why This Matters

🌍 Real World

Every Rust program starts with a <code>main</code> function. This structure is the foundation for building command-line tools, servers, and more.

💼 Career

Understanding program structure is essential for any Rust developer. It helps you organize code and build applications that run correctly.

1

Create the main function

Write a fn main() function with empty curly braces {} to start your Rust program.

Rust

fn main() {
    // Your code here
}

Hint

The main function is the entry point of a Rust program. It always starts with fn main() followed by curly braces.

2

Add a print statement inside main

Inside the main function, write println!("Hello, Rust!"); to print the greeting message.

Rust

fn main() {
    // Your code here
}

Hint

The println! macro prints text to the screen. Remember to include the exclamation mark and the semicolon.

3

Check the program structure

Make sure your program has the fn main() function and inside it the line println!("Hello, Rust!");.

Rust

fn main() {
    println!("Hello, Rust!");
    // Your code here
}

Hint

Double-check that your print statement is inside the main function and spelled exactly.

4

Run and display the output

Run the program and print the output. Write println!("Hello, Rust!"); inside main and then run it to see the message.

Rust

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

// Run the program to see the output

Hint

When you run the program, the console should show Hello, Rust!.

Practice

1. In a Rust program, where does the execution start?

easy

A. At the last line of the file

B. Inside the main function

C. Inside a function named start

D. At the first line of the file outside any function

Solution

1. Step 1: Understand Rust program entry point

   Rust programs always begin execution from the main function.

2. Step 2: Check other options

   Code outside functions or other function names like start are not entry points.

3. Final Answer:

   Inside the main function -> Option B

4. Quick Check:

   Rust starts at main() [OK]

Hint: Rust always runs code starting from main() [OK]

Common Mistakes:

• Thinking code outside main() runs first
• Assuming a function named start() runs automatically
• Believing execution starts at the last line

2. Which of the following is the correct way to write the main function in Rust?

easy

A. function main() { println!("Hello, world!"); }

B. main() { println!("Hello, world!"); }

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

D. def main() { println!("Hello, world!"); }

Solution

1. Step 1: Identify Rust function syntax

   Rust functions start with fn, followed by the name and parentheses.

2. Step 2: Check each option

   Only fn main() { println!("Hello, world!"); } uses fn main() correctly; others use wrong keywords.

3. Final Answer:

   fn main() { println!("Hello, world!"); } -> Option C

4. Quick Check:

   Rust functions start with fn [OK]

Hint: Rust functions start with fn keyword [OK]

Common Mistakes:

• Using function or def instead of fn
• Omitting fn keyword
• Missing parentheses after function name

3. What will be the output of this Rust program?

fn main() {
    println!("Start");
    {
        println!("Inside block");
    }
    println!("End");
}

medium

A. Start\nInside block\nEnd

B. Start\nEnd\nInside block

C. Inside block\nStart\nEnd

D. Start\nInside block

Solution

1. Step 1: Follow the code execution order

   The program prints "Start", then enters the block and prints "Inside block", then prints "End" after the block.

2. Step 2: Confirm output sequence

   The output lines appear in the order: Start, Inside block, End.

3. Final Answer:

   Start\nInside block\nEnd -> Option A

4. Quick Check:

   Code runs top to bottom inside blocks [OK]

Hint: Code runs step by step inside braces [OK]

Common Mistakes:

• Assuming block runs after all code
• Mixing order of print statements
• Ignoring braces as code grouping

4. Identify the error in this Rust program:

fn main() {
    println!("Hello");
    // Missing closing brace

medium

A. println! macro is misspelled

B. Missing semicolon after println!

C. Incorrect comment syntax

D. Missing closing brace '}' for main function

Solution

1. Step 1: Check code structure

   The main function starts with fn main() { but never closes with a }.

2. Step 2: Verify other syntax

   The semicolon after println! is present, comment syntax is correct, and println! is spelled correctly.

3. Final Answer:

   Missing closing brace '}' for main function -> Option D

4. Quick Check:

   Every { needs a matching } [OK]

Hint: Count opening and closing braces carefully [OK]

Common Mistakes:

• Forgetting to close function with }
• Confusing comment syntax with errors
• Missing semicolon errors instead of braces

5. You want to add a comment explaining why your Rust program prints "Hello". Which is the correct way to add a single-line comment inside the main function?

hard

A. // This prints Hello
println!("Hello");

B. # This prints Hello
println!("Hello");

C. /* This prints Hello */ println!("Hello");

D. println!("Hello");

Solution

1. Step 1: Identify Rust comment syntax

   Rust uses // for single-line comments and /* */ for block comments.

2. Step 2: Check each option

   Only // This prints Hello println!("Hello"); uses Rust's single-line comment syntax correctly; /* ... */ is a block comment, # is Python-style, and <!-- ... --> is HTML.

3. Final Answer:

   // This prints Hello println!("Hello"); -> Option A

4. Quick Check:

   Single-line comments start with // [OK]

Hint: Use // for single-line comments in Rust [OK]

Common Mistakes:

• Using # or for comments
• Confusing block comments with single-line
• Placing comments inside println! macro