Comment importer un module depuis un autre fichier en Rust : guide pour débutants

Comment inclure un module depuis un autre fichier en Rust : du débutant à l'utilisateur averti

Avez-vous déjà écrit du code en Rust et réalisé soudainement que votre main.rs se transformait en un monstre géant de 500 lignes ? Cela vous dit quelque chose ? Ou peut-être commencez-vous tout juste à apprendre Rust et souhaitez-vous comprendre comment organiser correctement votre code en le divisant en plusieurs fichiers. La question "How can I include a module from another file from the same project?" est l'une des plus populaires sur Stack Overflow, et pour cause. Le système de modules de Rust est à la fois puissant et... un peu contre-intuitif pour les débutants.

Dans cet article, nous allons tout détailler de A à Z : comment créer un module, comment l'importer, quels sont les pièges à éviter et comment ne pas marcher sur un râteau. C'est parti !

Pourquoi les modules en Rust ne sont pas simplement un "include" ?

Si vous venez de Python ou JavaScript, vous êtes habitué à import ou require. En Rust, c'est un peu différent. Il n'y a pas de "prends ce fichier et utilise-le" magique. Rust utilise plutôt un système de modules déclaratif. Vous devez explicitement dire au compilateur : "Hé, ce fichier fait partie de mon projet, et voici comment il s'appelle".

La règle principale à retenir est : chaque fichier est un module, mais tous les modules ne sont pas des fichiers. Cela ressemble à une énigme, n'est-ce pas ? On va éclaircir tout ça.

Structure du projet : par où commencer

Supposons que vous ayez un projet avec cette structure :

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

Ici, greetings.rs est un module simple, et utils/ est un dossier contenant un module. Apprenons à les importer.

Méthode 1 : Importer un fichier-module simple

Le cas le plus basique. Vous avez greetings.rs avec une fonction :

// greetings.rs\npub fn say_hello() {\n    println!("Bonjour depuis le module greetings !");\n}

Pour utiliser ce module dans main.rs, vous devez faire deux choses :

\n
1. Déclarer le module avec le mot-clé mod
\n
2. Importer les éléments nécessaires avec use
\n

// main.rs\nmod greetings; // déclare le module\n\nuse greetings::say_hello; // importe la fonction\n\nfn main() {\n    say_hello(); // utilise\n}

Et voilà ! Rust cherche automatiquement le fichier greetings.rs dans le même dossier que main.rs. Si le fichier est trouvé, le module est importé.

Important : la fonction say_hello est marquée comme pub. Si vous oubliez pub, le compilateur vous dira que la fonction est privée et inaccessible depuis l'extérieur. C'est l'une des erreurs les plus fréquentes chez les débutants.

Méthode 2 : Module dans un dossier (mod.rs ou lib.rs)

Lorsque votre projet s'agrandit, il est pratique de regrouper les modules dans des dossiers. Pour cela, on utilise un fichier mod.rs à l'intérieur du dossier. Il sert de "point d'entrée" du module.

Créons un dossier utils/ et à l'intérieur un fichier mod.rs :

// utils/mod.rs\npub mod helpers; // déclare le module imbriqué

Créons maintenant helpers.rs :

// utils/helpers.rs\npub fn do_something() {\n    println!("Faire quelque chose d'utile");\n}

Dans main.rs, on importe comme ceci :

// main.rs\nmod utils; // déclare le module utils (cherche utils/mod.rs)\n\nuse utils::helpers::do_something;\n\nfn main() {\n    do_something();\n}

Notez que mod utils; demande à Rust de chercher utils/mod.rs ou utils.rs. S'il trouve mod.rs — parfait, s'il trouve utils.rs — cela fonctionne aussi. Mais vous ne pouvez pas avoir les deux fichiers en même temps — le compilateur serait confus.

Méthode 3 : Approche moderne (Rust 201