Modules and Packages

# CHAPTER 16

Modules and Packages #

1. Chapter Introduction #

2. Learning Objectives #

• Understand the difference between a Package, Crate, and Module.

• Create inline modules.

• Split code into multiple files and folders.

• Use the pub keyword to manage privacy (Encapsulation).

• Install and use third-party crates from crates.io.

3. Packages, Crates, and Modules #

1. 1. Package: What you create when you type cargo new. It contains a Cargo.toml file.

1. 2. Crate: A tree of modules that produces an executable binary or a library. (e.g., main.rs is the "crate root" for a binary crate).

1. 3. Module: A way to organize code within a Crate into named, nested blocks.

4. Creating Inline Modules and Privacy #

// Define a module named 'network'
mod network {
    // This is private!
    fn connect_internal() {
        println!("Connecting internally...");
    }

    // This is public!
    pub fn connect() {
        println!("Connecting to the internet...");
        // A public function can call a private function in the same module
        connect_internal(); 
    }
}

fn main() {
    // Call the function using the path
    network::connect();

    // network::connect_internal(); // ERROR: Function is private!
}

5. Splitting Code into Multiple Files #

1. Update src/main.rs: Tell Rust to look for a file or folder named network.

// This tells Rust: "Look for a file named network.rs or a folder named network/mod.rs"
mod network; 

fn main() {
    network::connect();
}

2. Create a new file src/network.rs:

// Notice we DO NOT use 'mod network {}' in this file! 
// The file itself IS the module.

pub fn connect() {
    println!("Connecting from a separate file!");
}

6. The use Keyword #

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new(); // Much shorter!
}

7. Third-Party Crates (Cargo.toml) #

To use an external crate, you add it to your Cargo.toml file under [dependencies]. You can do this manually, or by using the terminal:

# Downloads the random number generator crate and adds it to Cargo.toml
cargo add rand

Now, you can use it in your code!

use rand::Rng; // Bring the Rng trait into scope

fn main() {
    // Generate a random number between 1 and 100
    let secret_number = rand::thread_rng().gen_range(1..=100);
    println!("Random number: {}", secret_number);
}

8. Common Mistakes #

• Forgetting pub on Struct Fields: If you make a struct public (pub struct User), its *fields* are still private by default! You must explicitly mark the fields you want to expose: pub email: String.

• Using mod in the wrong place: Beginners often put mod network; inside network.rs. You only declare mod in the parent file (usually main.rs or lib.rs) to build the module tree.

9. Best Practices #

• Organize by Domain: Group your files by feature (e.g., mod auth;, mod database;).

• Use absolute paths for clarity: When bringing things into scope, prefer absolute paths starting with crate:: (e.g., use crate::network::connect;).

10. Exercises #

1. 1. Create a new Cargo project.

1. 2. Create a new file math.rs containing a pub fn add(a: i32, b: i32) -> i32.

1. 3. In main.rs, declare mod math; and call the add function. Print the result.

11. MCQs with Answers #

12. Interview Questions #

• Q: Explain Rust's module system and how the mod keyword differs from the import or require keywords in other languages. (Answer: mod builds the module tree and tells the compiler what files to include; use merely creates a shortcut path).

• Q: How does Rust handle Encapsulation (Access Modifiers)?

13. Summary #

14. Next Chapter Recommendation #