Program structure in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the entry point of a Rust program?

The entry point of a Rust program is the main function. It is where the program starts running.

beginner

How do you define a function in Rust?

You define a function in Rust using the fn keyword, followed by the function name and parentheses. For example: fn greet() {}

intermediate

What is the purpose of the use keyword in Rust?

The use keyword brings modules, functions, or types into scope so you can use them without writing the full path every time.

intermediate

What is a module in Rust and why is it useful?

A module is a way to organize code into separate namespaces. It helps keep code clean and manageable by grouping related functions, structs, and other items.

beginner

How do you write comments in Rust?

Single-line comments start with //. Multi-line comments are enclosed between /* and */. Comments help explain code to others or yourself.

What keyword starts the main function in a Rust program?

A function

B main

C start

D fn

The fn keyword is used to define any function, including main.

Which symbol is used to write a single-line comment in Rust?

A //

B #

C /*

D <!--

Single-line comments in Rust start with //.

What does the use keyword do in Rust?

A Defines a new function

B Imports code into scope

C Starts the program

D Declares a variable

The use keyword brings modules or items into scope for easier access.

Which of these is a correct way to define a function named hello in Rust?

A fn hello() {}

B function hello() {}

C def hello() {}

D func hello() {}

Rust uses fn to define functions.

Why are modules useful in Rust?

A To speed up the program

B To declare variables

C To organize code into namespaces

D To write comments

Modules help organize code by grouping related items into namespaces.

Explain the basic structure of a Rust program including the main function and modules.

Think about where the program starts and how code is grouped.

Describe how comments are written in Rust and why they are important.

Comments help others understand your code.

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