Examples of Creating Modules in Rust

Explore practical examples of creating modules in Rust to organize your code effectively.
By Jamie

Understanding Modules in Rust

In Rust, modules are a way to organize code into separate namespaces, which can help improve the structure and readability of your code. Modules allow you to group related functionality, making it easier to manage larger codebases. Here are three diverse examples of creating modules in Rust that demonstrate how you can encapsulate functionality and share it across your application.

1. Basic Module Creation

Context

This example demonstrates how to create a simple module that contains a function to calculate the area of a rectangle. This is a foundational example suitable for beginners.

mod geometry {
    pub fn rectangle_area(width: f64, height: f64) -> f64 {
        width * height
    }
}

fn main() {
    let width = 5.0;
    let height = 3.0;
    let area = geometry::rectangle_area(width, height);
    println!("The area of the rectangle is: {}", area);
}

Notes

  • The pub keyword makes the rectangle_area function accessible outside the module.
  • This example highlights the modular structure, allowing for code reuse.

2. Nested Modules

Context

This example illustrates how to create nested modules. Here, we create a module containing submodules that handle different shapes, such as rectangles and circles.

mod shapes {
    pub mod rectangle {
        pub fn area(width: f64, height: f64) -> f64 {
            width * height
        }
    }

    pub mod circle {
        const PI: f64 = 3.14159;
        pub fn area(radius: f64) -> f64 {
            PI * radius * radius
        }
    }
}

fn main() {
    let rect_area = shapes::rectangle::area(5.0, 3.0);
    let circle_area = shapes::circle::area(2.0);
    println!("Rectangle area: {}, Circle area: {}", rect_area, circle_area);
}

Notes

  • Nested modules help organize related functions logically.
  • This structure is beneficial in larger projects where various components need to be neatly categorized.

3. Module with Structs and Traits

Context

In this example, we will create a module that defines a struct and implements a trait. This illustrates how modules can encapsulate data types and their associated behaviors.

mod animals {
    pub struct Dog {
        pub name: String,
        pub age: u8,
    }

    pub trait Bark {
        fn bark(&self);
    }

    impl Bark for Dog {
        fn bark(&self) {
            println!("{} says: Woof!", self.name);
        }
    }
}

fn main() {
    let my_dog = animals::Dog { name: String::from("Buddy"), age: 4 };
    my_dog.bark();
}

Notes

  • This example shows how to define a struct within a module, promoting encapsulation.
  • Implementing a trait allows for polymorphic behavior, enhancing the flexibility of your code.

By utilizing modules effectively, you can create well-structured and maintainable Rust applications. These examples of creating modules in Rust demonstrate different approaches and use cases that can be tailored to your specific programming needs.