Why modules are used in Rust - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Purpose of Modules in Rust

Why do Rust programmers use modules in their code?

A To make the program run faster by compiling modules separately

B To allow multiple main functions in the same project

C To automatically generate documentation without comments

D To organize code into separate namespaces and control visibility

💡 Hint

Think about how you keep your desk tidy by putting things in drawers.

Modules help organize code into groups and control which parts are visible outside. This keeps code clean and easier to manage.

❓ Predict Output

intermediate

Output of Module Visibility Example

What is the output of this Rust code?

Rust

mod kitchen {
    pub fn cook() {
        println!("Cooking food");
    }
    fn clean() {
        println!("Cleaning kitchen");
    }
}

fn main() {
    kitchen::cook();
    // kitchen::clean(); // Uncommenting this line causes error
}

A Cleaning kitchen

B Cooking food

C Cooking food\nCleaning kitchen

D Compilation error due to private function call

💡 Hint

Only functions marked pub can be called from outside the module.

The function cook is public and can be called from main. The function clean is private and cannot be called outside kitchen.

🔧 Debug

advanced

Fix the Module Import Error

Why does this Rust code cause a compilation error?

Rust

mod garden {
    pub fn plant() {
        println!("Planting seeds");
    }
}

fn main() {
    plant();
}

A Cannot call functions from modules in main

B Function plant is private; make it public

C Function plant is not in scope; call it as garden::plant()

D Missing semicolon after mod garden declaration

💡 Hint

Think about how to access functions inside modules from outside.

The function plant is public but must be called with its full path garden::plant() because it is inside the module garden.

📝 Syntax

advanced

Identify the Syntax Error in Module Declaration

Which option contains the correct syntax to declare a module named tools with a public function hammer?

A mod tools { pub fn hammer() { println!("Hammering"); } }

B module tools { pub fn hammer() { println!("Hammering"); } }

C mod tools pub fn hammer() { println!("Hammering"); }

D mod tools { fn hammer() pub { println!("Hammering"); } }

💡 Hint

Remember the keyword to declare a module and how to mark functions public.

The correct keyword is mod. Functions are marked public with pub fn. Curly braces must enclose the module body.

🚀 Application

expert

How Many Items Are Accessible?

Given this Rust code, how many items can be accessed from main?

Rust

mod library {
    pub mod books {
        pub fn read() {}
        fn secret() {}
    }
    fn helper() {}
    pub fn open() {}
}

fn main() {
    // Which of these can be called here?
    // library::open();
    // library::helper();
    // library::books::read();
    // library::books::secret();
}

A 2

B 3

C 4

D 1

💡 Hint

Count only public items accessible from main.

Only library::open() and library::books::read() are public and accessible. The others are private.