Como conectar um módulo de outro arquivo em Rust: guia para iniciantes

Como incluir um módulo de outro arquivo em Rust: do iniciante ao usuário confiante

Você já escreveu código em Rust e de repente percebeu que seu main.rs está se transformando em um monstro gigante de 500 linhas? Familiar? Ou talvez você esteja apenas começando a aprender Rust e queira entender como organizar o código corretamente, dividindo-o em vários arquivos. A pergunta "How can I include a module from another file from the same project?" é uma das mais populares no Stack Overflow, e não é à toa. O sistema de módulos do Rust é ao mesmo tempo poderoso e... um pouco não óbvio para iniciantes.

Neste artigo, vamos abordar tudo do início ao fim: como criar um módulo, como conectá-lo, quais são as armadilhas e como não pisar em cascas de banana. Vamos lá!

Por que módulos em Rust não são simplesmente "include"?

Se você vem do Python ou JavaScript, está acostumado com import ou require. Em Rust, é um pouco diferente. Aqui não existe um mágico "pegue o arquivo e use". Em vez disso, o Rust usa um sistema de módulos declarativo. Você deve dizer explicitamente ao compilador: "Ei, este arquivo é parte do meu projeto, e aqui está como ele se chama".

A regra principal que você precisa lembrar: cada arquivo é um módulo, mas nem todo módulo é um arquivo. Parece um enigma, não é? Vamos entender agora.

Estrutura do projeto: por onde começar

Suponha que você tenha um projeto com esta estrutura:

my_project/\n├── Cargo.toml\n├── src/\n│   ├── main.rs\n│   ├── greetings.rs\n│   └── utils/\n│       ├── mod.rs\n│       └── helpers.rs

Aqui, greetings.rs é um módulo simples, e utils/ é uma pasta com um módulo. Vamos aprender como conectá-los.

Método 1: Conectando um arquivo-módulo simples

O caso mais básico. Você tem greetings.rs com uma função:

// greetings.rs\npub fn say_hello() {\n    println!("Olá do módulo greetings!");\n}

Para usar este módulo em main.rs, você precisa fazer duas coisas:

\n
1. Declarar o módulo usando a palavra-chave mod
\n
2. Importar os elementos necessários usando use
\n

// main.rs\nmod greetings; // declaramos o módulo\n\nuse greetings::say_hello; // importamos a função\n\nfn main() {\n    say_hello(); // usamos\n}

Pronto! O Rust automaticamente procura o arquivo greetings.rs na mesma pasta onde está main.rs. Se o arquivo for encontrado, o módulo está conectado.

Importante: a função say_hello está marcada como pub. Se esquecer o pub, o compilador dirá que a função é privada e inacessível externamente. Este é um dos erros mais comuns de iniciantes.

Método 2: Módulo em pasta (mod.rs ou lib.rs)

Quando seu projeto cresce, é conveniente agrupar módulos em pastas. Para isso, usa-se o arquivo mod.rs dentro da pasta. Ele serve como "ponto de entrada" para o módulo.

Vamos criar a pasta utils/ e dentro dela o mod.rs:

// utils/mod.rs\npub mod helpers; // declaramos o módulo aninhado

Agora criamos helpers.rs:

// utils/helpers.rs\npub fn do_something() {\n    println!("Fazendo algo útil");\n}

Em main.rs, conectamos assim:

// main.rs\nmod utils; // declaramos o módulo utils (procura por utils/mod.rs)\n\nuse utils::helpers::do_something;\n\nfn main() {\n    do_something();\n}

Observe: mod utils; diz ao Rust para procurar utils/mod.rs ou utils.rs. Se encontrar mod.rs — ótimo, se encontrar utils.rs — também serve. Mas não pode ter ambos os arquivos ao mesmo tempo — o compilador ficará confuso.

Método 3: Abordagem moderna (Rust 201