Cargo, crate, module : organiser son code

Les fondations de l'organisation en Rust : une vue d'ensemble

Une bonne organisation du code est cruciale pour la maintenabilité, la lisibilité et la scalabilité de tout projet logiciel. Rust fournit un ensemble d'outils et de concepts puissants pour vous aider à structurer votre code de manière claire et efficace. Au coeur de cette organisation se trouvent trois éléments clés : Cargo, le gestionnaire de projet et de dépendances ; les crates, qui sont les unités de compilation et de distribution ; et les modules, qui permettent de partitionner et d'encapsuler le code au sein d'un crate. Comprendre comment ces trois éléments interagissent est fondamental pour développer des applications Rust robustes et bien architecturées.

Dans ce sous-chapitre, nous allons explorer en détail chacun de ces concepts. Nous verrons comment Cargo simplifie la création, la compilation et la gestion des dépendances de vos projets. Nous distinguerons les différents types de crates et leur rôle. Enfin, nous plongerons dans le système de modules de Rust pour apprendre à diviser notre code en unités logiques, à contrôler la visibilité et à gérer les espaces de noms. Maîtriser ces outils vous permettra non seulement d'écrire du code Rust, mais aussi de penser comme un développeur Rust, en adoptant les conventions et les bonnes pratiques de l'écosystème.

Cargo : votre chef d'orchestre pour les projets Rust

Cargo est l'outil officiel de gestion de projet et de construction (build system) pour Rust. Si vous avez déjà travaillé avec des outils comme npm (Node.js), pip (Python), ou Maven (Java), vous trouverez des similitudes, mais Cargo est profondément intégré à l'écosystème Rust et offre une expérience très fluide. Cargo s'occupe de nombreuses tâches fastidieuses :

• Création de projet : Avec `cargo new nom_du_projet` pour un exécutable ou `cargo new --lib nom_de_la_bibliotheque` pour une bibliothèque, Cargo initialise une structure de répertoires standard et un fichier `Cargo.toml`.
• Gestion des dépendances : Vous déclarez les bibliothèques externes (d'autres crates) dont votre projet a besoin dans le fichier `Cargo.toml`. Cargo se charge de les télécharger depuis crates.io (le registre officiel des crates Rust) et de les compiler.
• Compilation : `cargo build` compile votre projet. Par défaut, il crée un build de développement (non optimisé, rapide à compiler). `cargo build --release` crée un build optimisé pour la production.
• Exécution : `cargo run` compile et exécute votre crate binaire principal.
• Tests : `cargo test` compile et exécute tous les tests unitaires et d'intégration de votre projet.
• Documentation : `cargo doc` génère la documentation de votre projet et de ses dépendances.
• Nettoyage : `cargo clean` supprime les artefacts de compilation.
• Vérification : `cargo check` vérifie rapidement votre code pour les erreurs sans passer par la phase de génération de l'exécutable, ce qui est plus rapide que `cargo build`.

Le fichier central pour Cargo est `Cargo.toml` (TOML signifie Tom's Obvious, Minimal Language). Il contient les métadonnées de votre package (nom, version, auteurs), la liste des dépendances, les profils de compilation, etc. Voici un exemple simple de `Cargo.toml` :

[package]
name = "mon_application"
version = "0.1.0"
edition = "2021" # Spécifie l'édition de Rust à utiliser

# Section des dépendances
[dependencies]
rand = "0.8.5" # Dépendance au crate 'rand', version 0.8.5
serde = { version = "1.0", features = ["derive"] } # Dépendance avec des fonctionnalités spécifiques

# Exemple d'une dépendance de développement (uniquement pour les tests, exemples, etc.)
[dev-dependencies]
criterion = "0.4"

Cargo simplifie énormément le flux de travail du développeur Rust, permettant de se concentrer sur l'écriture du code plutôt que sur la configuration complexe des outils de build.

Crates : les briques de construction de votre logiciel

Un crate est l'unité fondamentale de compilation en Rust. Lorsque `rustc` (le compilateur Rust) compile votre code, il prend un ou plusieurs fichiers source et produit un crate. Il existe deux types principaux de crates :

• Crate binaire (Binary Crate) : C'est un programme exécutable que vous pouvez lancer depuis la ligne de commande. Un crate binaire doit avoir une fonction `main()` qui sert de point d'entrée au programme. Par convention, le fichier source principal d'un crate binaire est `src/main.rs`. Un package peut avoir plusieurs crates binaires (par exemple, si vous construisez plusieurs outils en ligne de commande liés) ; dans ce cas, les sources des binaires supplémentaires se trouvent généralement dans `src/bin/*.rs`.
• Crate bibliothèque (Library Crate) : C'est une collection de fonctionnalités (fonctions, structures, modules, etc.) destinée à être utilisée par d'autres programmes (crates binaires ou d'autres crates bibliothèques). Un crate bibliothèque n'a pas de fonction `main()`. Son but est de fournir du code réutilisable. Par convention, le fichier source principal d'un crate bibliothèque est `src/lib.rs`. Un package peut contenir au plus un crate bibliothèque.

Un package Rust est une collection d'un ou plusieurs crates (au moins un, qui peut être un crate binaire ou un crate bibliothèque, ou les deux) qui fournit un ensemble de fonctionnalités. Le fichier `Cargo.toml` décrit le package. Quand vous ajoutez une dépendance dans `Cargo.toml`, vous ajoutez en fait une dépendance à un autre package, qui expose généralement un crate bibliothèque que votre code peut utiliser.

Le registre public crates.io héberge des milliers de packages (et donc de crates bibliothèques) que vous pouvez facilement intégrer dans vos projets via Cargo. Cette richesse de l'écosystème est l'une des grandes forces de Rust.

Modules : structurer et encapsuler votre code au sein d'un crate

Les modules sont le principal moyen d'organiser le code à l'intérieur d'un crate. Ils permettent de :

• Partitionner le code : Diviser un grand projet en morceaux plus petits et plus gérables.
• Contrôler la visibilité (encapsulation) : Définir quels éléments (fonctions, structs, enums, constantes, autres modules) sont publics (accessibles depuis l'extérieur du module) et lesquels sont privés (détails d'implémentation internes au module). Par défaut, tous les éléments d'un module sont privés. Vous utilisez le mot-clé `pub` pour rendre un élément public.
• Créer des espaces de noms : Eviter les conflits de noms entre différents éléments.

Vous définissez un module avec le mot-clé `mod`. Un module peut contenir d'autres modules, créant ainsi une hiérarchie.

// Dans src/lib.rs ou src/main.rs (le "crate root")

mod front_of_house {
    // Ce module est privé par défaut pour l'extérieur du crate.
    // Pour le rendre utilisable depuis main.rs, il pourrait être déclaré pub mod front_of_house;

    pub mod hosting { // Ce sous-module est public au sein de front_of_house et, si front_of_house est public, à l'extérieur.
        pub fn add_to_waitlist() { // Cette fonction est publique.
            println!("Ajout à la liste d'attente");
            seat_at_table(); // Peut appeler une fonction privée du même module.
        }

        fn seat_at_table() { // Cette fonction est privée, utilisable uniquement dans hosting.
            println!("Assis à la table");
        }
    }

    mod serving {
        fn take_order() {}
        fn serve_order() {}
        fn take_payment() {}
    }
}

// Pour utiliser des éléments d'un module, on utilise leur chemin complet ou le mot-clé `use`.
pub fn eat_at_restaurant() {
    // Chemin absolu depuis le crate root
    crate::front_of_house::hosting::add_to_waitlist();

    // Chemin relatif depuis le module courant (ici, le crate root)
    front_of_house::hosting::add_to_waitlist();
}

// On peut amener un chemin dans la portée avec `use`
use crate::front_of_house::hosting;
// Ou même amener la fonction directement
// use crate::front_of_house::hosting::add_to_waitlist;

pub fn another_way_to_eat() {
    hosting::add_to_waitlist();
    // Si on avait fait `use ...::add_to_waitlist;` on aurait pu appeler directement `add_to_waitlist();`
}

Les modules peuvent également être définis dans des fichiers séparés pour mieux organiser les projets plus importants. Si vous avez `mod jardin;` dans `src/lib.rs`, le compilateur cherchera le contenu du module `jardin` dans :

• `src/jardin.rs` (pour un module simple)
• `src/jardin/mod.rs` (pour un module contenant des sous-modules, qui seraient alors dans `src/jardin/sous_module.rs`)

Ce système de modules, combiné à Cargo et aux crates, offre une structure solide et flexible pour tous les types de projets Rust, des plus petits scripts aux systèmes logiciels les plus complexes.