**Course Title:** Mastering Rust: From Basics to Systems Programming **Section Title:** Modules, Crates, and Packages **Topic:** Organizing code with modules and visibility In previous topics, we explored the basics of Rust, including variables, data types, functions, and error handling. As your projects grow in complexity, it's essential to learn how to organize your code effectively using modules and manage visibility. In this topic, we will delve into the world of modules and visibility in Rust. **What are modules?** In Rust, a module is a collection of items, such as functions, types, and constants, that can be used together. Modules are the building blocks of Rust programs, and they help to organize code in a logical and reusable way. **Defining a module** To define a module in Rust, you use the `mod` keyword followed by the name of the module. For example: ```rust mod my_module { // items in the module } ``` You can define a module within another module, creating a hierarchy of modules. This is useful for organizing related items together. **Declaring module items** Once you have defined a module, you can declare items within it using the `fn`, `struct`, `enum`, and `type` keywords. For example: ```rust mod my_module { pub fn my_function() { println!("Hello, World!"); } } ``` In this example, the `my_function` function is declared within the `my_module` module. **Visibility** In Rust, visibility refers to the access level of an item. By default, items in a module are private, meaning they can only be accessed within that module. To make an item visible to other modules, you use the `pub` keyword. ```rust mod my_module { pub fn my_function() { println!("Hello, World!"); } } ``` In this example, the `my_function` function is made public using the `pub` keyword. **Types of visibility** Rust has three types of visibility: * **Private** (`pub(crate)`): Items are only accessible within the current crate. * **Public** (`pub`): Items are accessible from any crate. * **Module-public** (`pub(in crate)`, `pub(in $crate)`, `pub(in self)`, etc.): Items are accessible from within the current module and its descendants. **Importing modules** To use items from another module, you need to import the module using the `use` keyword. For example: ```rust mod my_module { pub fn my_function() { println!("Hello, World!"); } } fn main() { use my_module; my_module::my_function(); } ``` In this example, the `my_module` module is imported into the `main` function using the `use` keyword. **Re-exporting** If you want to make items from another module accessible from your module, you can re-export them using the `pub use` keyword. For example: ```rust mod my_module { pub fn my_function() { println!("Hello, World!"); } } pub mod my_re_exported_module { pub use my_module::my_function; } ``` In this example, the `my_function` function is re-exported from the `my_re_exported_module` module. **Supercharge your learning** To delve deeper into modules and visibility, we recommend reading the Rust Book's [chapter on modules](https://doc.rust-lang.org/book/ch07-02-packages-and-crates.html). **Practice makes perfect** To practice what you've learned, try creating a new Rust project with multiple modules and experiment with different visibility levels. **Leave a comment or ask for help** If you have any questions or need help with modules and visibility, leave a comment below. **What's next?** In the next topic, we will explore **Understanding traits and their role in Rust**.