How do you create and use modules in Rust

Modules in Rust are a way to organize code into separate namespaces, allowing you to group related functionality together. This helps in managing larger codebases and controlling the visibility of items. In this guide, we will explore how to create and use modules in Rust, along with examples to illustrate their usage.

1. Defining a Module

You can define a module using the mod keyword. By default, items in a module are private, meaning they cannot be accessed from outside the module unless explicitly marked as public using the pub keyword.

Example of Defining a Module


mod my_module {
    pub fn greet() {
        println!(`Hello from my_module!`);
    }
    fn private_function() {
        println!(`This is a private function.`);
    }
}
fn main() {
    my_module::greet(); // This will work
    // my_module::private_function(); // This will cause a compile-time error
}

Explanation of the Example

In this example, we define a module named my_module using the mod keyword.
Inside the module, we define a public function greet that can be accessed from outside the module.
We also define a private function private_function that cannot be accessed from outside the module.
In the main function, we can call greet, but attempting to call private_function will result in a compile-time error.

2. Nested Modules

Modules can be nested within other modules, allowing for a hierarchical organization of code. You can define a module inside another module using the same mod keyword.

Example of Nested Modules


mod outer {
    pub mod inner {
        pub fn inner_function() {
            println!(`Hello from inner_function!`);
        }
    }
}
fn main() {
    outer::inner::inner_function(); // Accessing the nested module function
}

Explanation of the Example

In this example, we define an outer module named outer and a nested module named inner.
Inside the inner module, we define a public function inner_function.
In the main function, we access the nested function using the full path outer::inner::inner_function.

3. Organizing Modules in Separate Files

Rust allows you to organize modules in separate files for better code organization. You can create a file named my_module.rs for the my_module module, and Rust will automatically include it when you declare the module in your main file.

Example of Organizing Modules in Separate Files


// main.rs
mod my_module; // Declare the module
fn main() {
    my_module::greet();
}
// my_module.rs
pub fn greet() {
    println!(`Hello from my_module!`);
}

Explanation of the Example

In this example, we declare the my_module module in the main.rs file using mod my_module;.
We create a separate file named my_module.rs where we define the greet function.
When we run the program, Rust automatically includes the contents of my_module.rs, allowing us to call the greet function from the main file.

4. Controlling Visibility

Modules allow you to control the visibility of items. By default, items are private, but you can use the pub keyword to make them public. This is useful for encapsulating functionality and exposing only what is necessary to the outside world.

Example of Controlling Visibility


mod my_module {
    pub fn public_function() {
        println!(`This is a public function.`);
    }
    fn private_function() {
        println!(`This is a private function.`);
    }
}
fn main() {
    my_module::public_function(); // This will work
    // my_module::private_function(); // This will cause a compile-time error
}

Explanation of the Example

In this example, we define a public function public_function that can be accessed from outside the module.
The private_function remains inaccessible from outside the module, demonstrating how visibility can be controlled.
In the main function, we can call public_function, but attempting to call private_function will result in a compile-time error.

5. Conclusion

Creating and using modules in Rust is essential for organizing code and managing visibility. By defining modules, you can encapsulate related functionality, control access to items, and improve the maintainability of your code. Whether you choose to nest modules or organize them in separate files, Rust's module system provides a robust framework for building scalable applications.