<h2>Fundamentos do Sistema de Módulos em Rust</h2>
<p>O sistema de módulos em Rust é o alicerce da organização de código profissional. Ao contrário de outras linguagens que usam convenções de diretórios, Rust oferece controle explícito sobre visibilidade e importação através de palavras-chave dedicadas. Entender <code>mod</code>, <code>pub</code> e <code>use</code> é essencial para estruturar projetos escaláveis e manuteníveis.</p>
<p>Um módulo é um namespace que agrupa código relacionado. Pode ser definido inline em um arquivo ou em estruturas de diretório. A palavra-chave <code>mod</code> declara um módulo; <code>pub</code> controla sua visibilidade; <code>use</code> traz itens para o escopo atual. Juntos, esses três conceitos formam um sistema robusto de encapsulamento.</p>
<h2>Declarando e Organizando Módulos com <code>mod</code></h2>
<h3>Módulos Inline</h3>
<p>Módulos podem ser declarados diretamente no arquivo usando blocos <code>mod {}</code>. Essa abordagem funciona bem para projetos pequenos ou quando o código está intimamente relacionado.</p>
<pre><code class="language-rust">// src/main.rs
mod calculos {
pub fn somar(a: i32, b: i32) -> i32 {
a + b
}
fn subtrair(a: i32, b: i32) -> i32 {
a - b
}
}
fn main() {
let resultado = calculos::somar(5, 3);
println!("Resultado: {}", resultado);
// calculos::subtrair(5, 3) causaria erro — função privada
}</code></pre>
<h3>Módulos em Arquivos Separados</h3>
<p>Para projetos maiores, organize módulos em arquivos. Rust busca automaticamente <code>nomemodulo.rs</code> quando você declara <code>mod nomemodulo</code>.</p>
<pre><code>src/
├── main.rs
├── utils.rs
└── operacoes/
├── mod.rs
├── aritmetica.rs
└── logica.rs</code></pre>
<p>Em <code>src/main.rs</code>:</p>
<pre><code class="language-rust">mod utils;
mod operacoes;
fn main() {
let resultado = utils::formatar("Teste");
println!("{}", resultado);
}</code></pre>
<p>Em <code>src/utils.rs</code>:</p>
<pre><code class="language-rust">pub fn formatar(texto: &str) -> String {
format!("Formatado: {}", texto)
}</code></pre>
<p>Para submódulos, crie um diretório com <code>mod.rs</code> que declare os submódulos:</p>
<pre><code class="language-rust">// src/operacoes/mod.rs
pub mod aritmetica;
pub mod logica;</code></pre>
<pre><code class="language-rust">// src/operacoes/aritmetica.rs
pub fn multiplicar(a: i32, b: i32) -> i32 {
a * b
}</code></pre>
<h2>Controlando Visibilidade com <code>pub</code></h2>
<p>A visibilidade em Rust segue um princípio: <strong>tudo é privado por padrão</strong>. Você deve explicitamente tornar públicos os itens que deseja exportar. Isso evita exposição acidental e força um design consciente da API.</p>
<pre><code class="language-rust">// src/biblioteca.rs
// Privado — não acessível fora deste módulo
struct Interno {
valor: i32,
}
// Público — acessível em qualquer lugar
pub struct Calculadora {
nome: String,
}
impl Calculadora {
// Privado — apenas para uso interno
fn validar(&self) -> bool {
true
}
// Público — faz parte da API pública
pub fn calcular(&self, x: i32) -> i32 {
if self.validar() {
x * 2
} else {
0
}
}
}
pub fn processar(entrada: &str) -> String {
format!("Processado: {}", entrada)
}</code></pre>
<p>Você também pode usar <code>pub(crate)</code> para tornar algo público apenas dentro do crate, ou <code>pub(in caminho)</code> para controle mais fino:</p>
<pre><code class="language-rust">pub(crate) fn funcao_interna() {
// Visível em todo o crate, mas não externamente
}
pub(in super) fn outra_funcao() {
// Visível apenas no módulo pai
}</code></pre>
<h2>Importando com <code>use</code></h2>
<p>A palavra-chave <code>use</code> traz itens de módulos para o escopo atual, evitando repetição de caminhos completos. Isso melhora a legibilidade significativamente em projetos reais.</p>
<h3>Importações Simples e Nesting</h3>
<pre><code class="language-rust">use std::collections::HashMap;
use std::fs::File;
use std::io::Read;
// Equivalente a:
use std::{
collections::HashMap,
fs::File,
io::Read,
};
fn exemplo() {
let mut mapa: HashMap<String, i32> = HashMap::new();
mapa.insert("chave".to_string(), 42);
}</code></pre>
<h3>Importações Seletivas</h3>
<p>Use <code>*</code> para importar todos os itens públicos de um módulo (com moderação):</p>
<pre><code class="language-rust">use std::collections::*;
fn listar() {
let _mapa: HashMap<String, i32> = HashMap::new();
let _vetor: Vec<String> = Vec::new();
}</code></pre>
<h3>Renomeando Imports</h3>
<p>Quando há conflitos de nomes ou para melhorar clareza:</p>
<pre><code class="language-rust">use std::fs::File as ArquivoRust;
use std::io::Result as IoResult;
fn abrir() -> IoResult<()> {
let _arquivo = ArquivoRust::open("teste.txt")?;
Ok(())
}</code></pre>
<h3>Importações em Projetos Reais</h3>
<pre><code class="language-rust">// src/main.rs
mod database;
mod api;
use database::conectar;
use api::servidor::{iniciar, Configuracao};
fn main() {
let config = Configuracao::padrao();
let _conn = conectar("localhost");
iniciar(config);
}</code></pre>
<h2>Conclusão</h2>
<p>Dominar o sistema de módulos em Rust é fundamental para desenvolvimento profissional. <strong>Primeiro</strong>, use <code>mod</code> para organizar código em namespaces lógicos — prefira arquivos separados em projetos maiores. <strong>Segundo</strong>, aplique <code>pub</code> conscientemente: exponha apenas o necessário e crie APIs claras e coesas. <strong>Terceiro</strong>, use <code>use</code> para tornar código legível, trazendo apenas os itens necessários para o escopo atual. Esses três conceitos juntos criam uma base sólida para escalabilidade e manutenção de código.</p>
<h2>Referências</h2>
<ul>
<li><a href="https://doc.rust-lang.org/book/ch07-00-managing-growing-projects-with-packages-modules-and-paths.html" target="_blank" rel="noopener noreferrer">The Rust Book - Modules</a></li>
<li><a href="https://doc.rust-lang.org/reference/items.html" target="_blank" rel="noopener noreferrer">Rust Reference - Items and Attributes</a></li>
<li><a href="https://doc.rust-lang.org/rust-by-example/mod.html" target="_blank" rel="noopener noreferrer">Rust By Example - Modules</a></li>
<li><a href="https://doc.rust-lang.org/std/" target="_blank" rel="noopener noreferrer">Official Rust Documentation - std lib overview</a></li>
<li><a href="https://github.com/rust-lang/rustlings" target="_blank" rel="noopener noreferrer">Rustlings - Exercises on Modules</a></li>
</ul>