Defining modules in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a module named math.

Rust

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

Drag options to blanks, or click blank then click option'

Acalc

Badd

Cmath

Dsum

Attempts:

3 left

💡 Hint

Common Mistakes

Using a function name instead of a module name.

Using a name that doesn't match the module's purpose.

The keyword mod is used to declare a module. Here, the module is named math.

2fill in blank

medium

Complete the code to make the function greet accessible outside the module.

Rust

mod greetings {
    [1] greet() {
        println!("Hello!");
    }
}

Drag options to blanks, or click blank then click option'

Apub fn

Blet

Cfn

Dmod

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to add pub to the function.

Using let or mod incorrectly.

Adding pub before fn makes the function public and accessible outside the module.

3fill in blank

hard

Fix the error in the code to correctly call the hello function from the salutations module.

Rust

pub mod salutations {
    pub fn hello() {
        println!("Hi!");
    }
}

fn main() {
    salutations::[1]();
}

Drag options to blanks, or click blank then click option'

Ahello

Bgreet

Chi

Dsay_hello

Attempts:

3 left

💡 Hint

Common Mistakes

Using a wrong function name that does not exist.

Forgetting the double colon :: syntax.

To call the function, use the module name followed by :: and the function name exactly as declared, which is hello.

4fill in blank

hard

Fill both blanks to define a nested module utils inside helpers and make the function print_msg public.

Rust

mod helpers {
    pub mod [1] {
        pub fn [2]() {
            println!("Message");
        }
    }
}

Drag options to blanks, or click blank then click option'

Autils

Bprint_msg

Cmessage

Ddisplay

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect module or function names.

Forgetting to make the module or function public.

The nested module is named utils and the function inside is print_msg, both made public.

5fill in blank

hard

Fill all three blanks to create a module config with a public constant VERSION and a public function show_version that prints it.

Rust

mod [1] {
    pub const [2]: &str = "1.0";
    pub fn [3]() {
        println!("Version: {}", [2]);
    }
}

Drag options to blanks, or click blank then click option'

Aconfig

BVERSION

Cshow_version

Dversion

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase for constant names.

Forgetting to make the constant or function public.

Mismatching names between constant and usage.

The module is config, the constant is VERSION, and the function is show_version which prints the version.

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