Defining modules in Rust - Step-by-Step Execution

Concept Flow - Defining modules

Start main.rs

↓

Declare module with mod

↓

Rust compiler looks for module file or inline code

↓

Module code is compiled

↓

Use module items with use or fully qualified path

↓

Program runs using module's functions/variables

This flow shows how Rust finds and compiles modules declared with mod, then how the main code uses them.

Execution Sample

Rust

mod greetings {
    pub fn hello() {
        println!("Hello from module!");
    }
}

fn main() {
    greetings::hello();
}

Defines a module greetings with a public function hello, then calls it from main.

Execution Table

Step	Action	Code Evaluated	Result/Output
1	Declare module greetings	mod greetings { ... }	Module greetings is registered
2	Define public function hello inside greetings	pub fn hello() { println!(...) }	Function hello is available publicly
3	Start main function	fn main() { ... }	Program entry point
4	Call greetings::hello()	greetings::hello();	Prints: Hello from module!
5	Program ends	}	Program terminates normally

💡 Program ends after main finishes execution

Variable Tracker

Variable	Start	After greetings::hello() call	Final
No variables	N/A	N/A	N/A

Key Moments - 2 Insights

Why do we need to use pub before the function hello?

Without pub, the function hello is private to the module and cannot be called from main. See execution_table step 2 and 4 where hello is declared public and then called.

What does mod greetings mean in the code?

It tells Rust to create a module named greetings. The compiler looks for code inside the braces or in greetings.rs file. See execution_table step 1.

Visual Quiz - 3 Questions

Look at the execution table, what happens at step 4?

A The program prints 'Hello from module!'

B The module greetings is declared

C The program ends

D The function hello is defined

💡 Hint

Check the 'Result/Output' column at step 4 in execution_table

At which step does the program start running main()?

A Step 1

B Step 3

C Step 2

D Step 5

💡 Hint

Look at the 'Action' column for when main() starts in execution_table

If we remove pub from the function hello, what will happen when calling greetings::hello()?

A It will print the message anyway

B Runtime error when calling hello

C Compilation error because hello is private

D The program will ignore the call

💡 Hint

Refer to key_moments about pub keyword and execution_table step 4

Concept Snapshot

Defining modules in Rust:
- Use mod keyword to declare a module
- Module code can be inline or in separate file
- Use pub to make functions accessible outside module
- Call module items with module_name::item_name
- Modules help organize code into namespaces

Full Transcript

This example shows how to define a module in Rust using the mod keyword. The module greetings contains a public function hello. The main function calls greetings::hello() which prints a message. The pub keyword is important to allow access to the function from outside the module. The execution steps show module declaration, function definition, main start, function call, and program end. Variables are not used here. Common confusions include why pub is needed and what mod means. The quiz tests understanding of these steps and concepts.

Practice

1. What keyword do you use in Rust to define a new module inside a file?

easy

A. module

B. use

C. mod

D. pub

Solution

1. Step 1: Understand Rust module declaration

   Rust uses the keyword mod to declare a module inside a file.

2. Step 2: Differentiate from other keywords

   use imports modules, pub makes items public, and module is not a Rust keyword.

3. Final Answer:

   mod -> Option C

4. Quick Check:

   Keyword for defining modules = mod [OK]

Hint: Remember: 'mod' means module in Rust [OK]

Common Mistakes:

• Using 'module' instead of 'mod'
• Confusing 'use' with 'mod'
• Forgetting 'mod' keyword

2. Which of the following is the correct syntax to declare a module named network in Rust?

easy

A. use network {}

B. module network {}

C. pub mod network() {}

D. mod network {}

Solution

1. Step 1: Recall correct module syntax

   The correct syntax to declare a module is mod name { } without parentheses.

2. Step 2: Check each option

   mod network {} uses mod network {} which is correct. module network {} uses 'module' which is invalid. pub mod network() {} adds parentheses which are not allowed. use network {} uses 'use' which is for importing.

3. Final Answer:

   mod network {} -> Option D

4. Quick Check:

   Module declaration = mod name {} [OK]

Hint: Modules use curly braces, no parentheses [OK]

Common Mistakes:

• Adding parentheses after module name
• Using 'module' instead of 'mod'
• Confusing 'use' with 'mod'

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

mod math {
    pub fn add(a: i32, b: i32) -> i32 {
        a + b
    }
}

fn main() {
    println!("{}", math::add(3, 4));
}

medium

A. 7

B. Compilation error

C. math::add(3, 4)

D. 0

Solution

1. Step 1: Check module and function visibility

   The function add is marked pub, so it can be accessed outside the module.

2. Step 2: Evaluate the function call

   Calling math::add(3, 4) returns 3 + 4 = 7, which is printed.

3. Final Answer:

   7 -> Option A

4. Quick Check:

   Public function call returns sum = 7 [OK]

Hint: Public functions in modules can be called with module::function [OK]

Common Mistakes:

• Forgetting 'pub' causes compilation error
• Expecting function name printed
• Confusing output with zero

4. Identify the error in this Rust code:

mod utils {
    fn helper() {
        println!("Helper function");
    }
}

fn main() {
    utils::helper();
}

medium

A. Function 'helper' is private and cannot be accessed outside the module

B. Missing semicolon after println!

C. Module 'utils' is not declared correctly

D. Cannot call functions inside modules

Solution

1. Step 1: Check function visibility

   The function helper is not marked pub, so it is private to the module.

2. Step 2: Understand access from main

   Trying to call utils::helper() from outside causes a compilation error due to privacy.

3. Final Answer:

   Function 'helper' is private and cannot be accessed outside the module -> Option A

4. Quick Check:

   Private functions can't be called outside module [OK]

Hint: Add 'pub' to functions to access them outside modules [OK]

Common Mistakes:

• Assuming all functions are public by default
• Ignoring privacy rules
• Thinking modules block all calls

5. You want to organize your Rust project by splitting code into two files: main.rs and network.rs. How do you correctly declare and use the network module in main.rs?

hard

A. Write pub mod network {} in main.rs and put code inside network.rs

B. Write mod network; in main.rs and make functions in network.rs public with pub

C. Write use network; in main.rs and declare mod network {} inside network.rs

D. Write extern crate network; in main.rs and import functions manually

Solution

1. Step 1: Understand module file linking

   To link an external file as a module, use mod network; in main.rs. This tells Rust to load network.rs.

2. Step 2: Make functions public in network.rs

   Functions inside network.rs must be marked pub to be accessible from main.rs.

3. Final Answer:

   Write mod network; in main.rs and make functions in network.rs public with pub -> Option B

4. Quick Check:

   Use mod filename; and pub functions for multi-file modules [OK]

Hint: Use 'mod filename;' in main and 'pub' for access [OK]

Common Mistakes:

• Using 'use' instead of 'mod' to declare modules
• Declaring mod inside the module file
• Using extern crate for local modules