Project Structure with Rust Modules and Crates

Rust offers powerful tools for modular and sustainable software development processes. The most important of these tools are Rust modules and Rust crates. Using modules and crates correctly in Rust programs increases the readability and reusability of projects. So, what are modules and crates, and how are they used in practice? We will examine these concepts in detail in this article.

What are Rust Modules?

Modules in Rust allow code to be logically partitioned and organized. With modules, you can separate code blocks across one or more files, and specify public or private access.

Defining a Rust Module

// src/main.rs
mod hesaplama {
    pub fn topla(a: i32, b: i32) -> i32 {
        a + b
    }
}

fn main() {
    let sonuc = hesaplama::topla(3, 5);
    println!("Sonuç: {}", sonuc);
}

In the example above, we defined a module by writing mod hesaplama and exposed the topla function outside with the pub keyword. We used the path hesaplama::topla to access the module and function.

Rust Crates (Libraries)

A crate is the main unit in the Rust ecosystem that can be compiled independently as an application (binary crate) or as a library (library crate). Every Rust project contains at least one crate. When you open a new project with Cargo, a crate is created by default.

Creating and Using a Crate

// Start a new crate (Terminal command):
cargo new benim_lib

// src/lib.rs
pub fn selamla() {
    println!("Merhaba, Rust!");
}

A crate can contain modules defined with mod in the project, or it can include other crates as dependencies via Cargo.toml. To use a crate you've created in another crate, you need to add it to your Cargo.toml file.

Project Organization with Rust Modules and Crates

In large projects, it is possible to establish a layered and clean structure using modules and crates. For example, you can store business logic, data access, and interface code in different modules or separate crates to increase reusability. The concepts of Rust modules and crates are the main building blocks for sustainable and testable software.

Using Multi-file Modules

// src/hayat.rs
pub fn anlam() -> u8 {
    42
}

// src/main.rs
mod hayat;

fn main() {
    println!("Hayatın anlamı: {}", hayat::anlam());
}

In this example, the hayat.rs file has been defined as a separate module and is used in the main file with the expression mod hayat;. As the code grows, project management becomes much easier thanks to modules and crates.

Conclusion

Rust modules and Rust crates are indispensable for the sustainable and scalable development of modern software. Proper modularization and crate usage make both the readability and maintenance of the code easier. Using these structures effectively while developing projects with Rust provides you with professional and rapid results.