Module Basics

🏠 Rust Modules: Building Your Code Mansion

Imagine you’re building the biggest, coolest mansion ever. But here’s the thing — you can’t just throw all the furniture, toys, food, and clothes into ONE giant room! That would be chaos! 🎢

Instead, you organize everything into rooms. The kitchen has cooking stuff. The bedroom has your bed. The playroom has your toys. Each room has a door — some doors are open for everyone, and some are private (like your secret diary room 🔐).

That’s exactly what Rust modules are! They’re rooms in your code mansion that keep everything organized and tidy.

🧱 What is a Module?

A module is like a room in your house. It’s a container that holds related code together.

Think about it:

• 🍳 Kitchen → cooking functions
• 🛏️ Bedroom → sleeping functions
• 🎮 Playroom → game functions

In Rust, we create a “room” using the mod keyword:

mod kitchen {
    fn cook_pasta() {
        println!("Cooking!");
    }
}

That’s it! You just built a kitchen room with a cooking function inside!

📁 Module File Structure

Now, imagine your mansion gets SO big that you can’t fit everything on one blueprint. You need separate blueprints for each room!

Rust gives you two ways to organize modules in files:

Way 1: Room Inside the Main File

Put everything in one file (like a small apartment):

// main.rs
mod kitchen {
    pub fn cook() {}
}

mod bedroom {
    pub fn sleep() {}
}

Way 2: Separate Files for Each Room

Each room gets its own file (like a real mansion):

my_project/
├── src/
│   ├── main.rs
│   ├── kitchen.rs
│   └── bedroom.rs

In main.rs, you just announce the rooms exist:

mod kitchen;  // Rust looks for
              // kitchen.rs
mod bedroom;  // Rust looks for
              // bedroom.rs

Way 3: Folders for Big Rooms

Super big rooms get their own folder with a special mod.rs file:

src/
├── main.rs
└── kitchen/
    ├── mod.rs
    └── oven.rs

🛤️ Paths: Finding Your Way

Imagine you’re in the living room and want something from the kitchen. You need directions!

In Rust, paths are like addresses to find things in your code mansion.

Two Types of Paths:

🏠 Absolute Path — Start from the front door:

crate::kitchen::cook_pasta();
// "From the main entrance,
//  go to kitchen,
//  find cook_pasta"

👣 Relative Path — Start from where you are:

kitchen::cook_pasta();
// "From here, go to kitchen,
//  find cook_pasta"

The super Keyword

super means “go to the parent room” (like going upstairs):

mod kitchen {
    mod pantry {
        fn get_ingredient() {
            super::cook();
            // Go up to kitchen,
            // then call cook()
        }
    }
    fn cook() {}
}

🔓 The pub Keyword: Open or Locked Doors

By default, every room in Rust has a locked door. Nobody outside can peek in!

To open the door, use pub:

mod kitchen {
    pub fn cook() {
        // Anyone can use this!
    }

    fn secret_recipe() {
        // Private! Only kitchen
        // code can use this
    }
}

Making Parts Public

You can make different things public:

pub mod kitchen {      // Public room
    pub fn cook() {}   // Public function
    pub struct Oven {  // Public struct
        pub temp: i32, // Public field
    }
}

🎭 Visibility Modifiers: Who Can Enter?

Rust has special “access passes” for different levels of privacy:

Example:

mod house {
    pub(crate) fn family_only() {
        // Only code in this
        // project can call me
    }

    mod bedroom {
        pub(super) fn wake_up() {
            // Only bedroom and
            // house can call me
        }
    }
}

Think of it like:

• pub = Front door (anyone can enter)
• pub(crate) = Family members only
• pub(super) = This room + parents

📦 The use Keyword: Creating Shortcuts

Imagine saying the full address every time:

“Hey, go to main mansion, then kitchen wing, then cooking area, then get the pasta maker!”

Exhausting! 😫

The use keyword creates a shortcut:

// Without shortcut:
crate::kitchen::cooking::make_pasta();
crate::kitchen::cooking::make_pizza();

// Create a shortcut!
use crate::kitchen::cooking;

// Now just say:
cooking::make_pasta();
cooking::make_pizza();

Bring It All the Way In:

use crate::kitchen::cooking::make_pasta;

// Now just:
make_pasta();

Multiple Shortcuts at Once:

use crate::kitchen::{
    make_pasta,
    make_pizza,
    make_salad
};

The Star Shortcut:

use crate::kitchen::*;
// Brings EVERYTHING from
// kitchen (use carefully!)

🏷️ The as Keyword: Nicknames!

What if two things have the same name? Like two friends both named “Max”?

Give them nicknames with as:

use std::fmt::Result;
use std::io::Result as IoResult;

fn do_stuff() -> Result {
    // This is fmt::Result
    Ok(())
}

fn read_file() -> IoResult<String> {
    // This is io::Result
    Ok(String::new())
}

Another example:

use crate::kitchen::Oven
    as KitchenOven;
use crate::bakery::Oven
    as BakeryOven;

// Now no confusion!
let home = KitchenOven::new();
let shop = BakeryOven::new();

🎯 Putting It All Together

Let’s build a mini mansion!

src/
├── main.rs
├── kitchen.rs
└── games/
    ├── mod.rs
    └── cards.rs

main.rs:

mod kitchen;
mod games;

use kitchen::cook_dinner;
use games::cards::play_uno;

fn main() {
    cook_dinner();
    play_uno();
}

kitchen.rs:

pub fn cook_dinner() {
    println!("Dinner ready!");
}

fn secret_recipe() {
    // Private helper
}

games/mod.rs:

pub mod cards;

games/cards.rs:

pub fn play_uno() {
    println!("UNO!");
}

🌟 Quick Mental Map

graph TD
    A["crate - Your Mansion"] --> B["mod kitchen"]
    A --> C["mod bedroom"]
    A --> D["mod games"]
    D --> E["mod cards"]
    D --> F["mod board"]

    style A fill:#667eea
    style B fill:#4ECDC4
    style C fill:#4ECDC4
    style D fill:#FF6B6B
    style E fill:#FFE66D
    style F fill:#FFE66D

💡 Remember These Magic Words!

🚀 You Did It!

You now understand how to:

• ✅ Create modules (rooms)
• ✅ Organize files (blueprints)
• ✅ Navigate with paths (addresses)
• ✅ Control access with pub (doors)
• ✅ Use visibility modifiers (access passes)
• ✅ Create shortcuts with use
• ✅ Rename with as (nicknames)

Your Rust code mansion is ready to grow! 🏰