Les traits en Rust

1. Création d’une caisse et d’un exécutable client

On commence par créer un projet dédié à notre exemple. Il s’agira de créer un trait relatif aux animaux.

On crée donc une librairie (une bibliothèque) Rust, qui n’est ni plus ni moins qu’une caisse (crate), dédiée à ce trait :

cargo new animal --lib 
     Created library `Animal` package 

On a utilisé l’option --lib, qui nous permet de créer une librairie (contrairement aux projets précédents qui étaient des exécutables).

Regardons le code par défaut dans le fichier lib.rs :

#[cfg(test)] 
mod tests { 
    #[test] 
    fn it_works() { 
        let result = 2 + 2; 
        assert_eq!(result, 4); 
    } 
} 

On voit qu’il y a dans ce code un module tests qui contient une fonction it_works.

La clause #[cfg(test)] ainsi que le #[test] indiquent que ce code est utilisable via la commande cargo test.

Nous allons nettoyer un peu tout cela de manière à pouvoir l’utiliser depuis l’extérieur de la caisse. On retire les lignes relatives au test et on remplace cette ligne :

assert_eq!(result, 4); 

par celle-ci :

assert_eq!(result, 3); 

Ainsi, quand on appellera la fonction, on obtiendra un message de panique lié à l’assert (en effet, 4 n’est pas égal à 3). Notre nouveau code devient pour le moment le suivant :

#![allow(unused)] 
 
pub mod tests { 
 
    pub fn it_works() { 
        let result = 2 + 2; 
        assert_eq!(result, 3); 
    } 
} 

Pour l’instant, on cherche seulement à vérifier que notre caisse est utilisable depuis l’extérieur. Bien évidemment, nous renommerons le module et ajouterons les fonctions qui nous intéressent.

Créons à présent un projet exécutable utilisant la caisse précédente. Nous nommons cet exécutable...

1. Introduction

On peut à présent chercher à avoir une fonction qui prend en paramètre un trait. En effet, cela permet d’avoir en réalité toutes sortes de structures éligibles pour être passées en paramètre. Dans notre exemple, on passerait un Animal en paramètre de la fonction, c’est-à-dire que l’on pourrait aussi bien avoir un Chat qu’un Chien. En science informatique, on parle parfois, pour désigner ce mécanisme, de transtypage.

2. Exemple de trait en paramètre

Nous allons ajouter une fonction afficher dans notre exécutable client. Le but est d’appeler la méthode afficher du trait Animal. On nomme cette méthode afficher_trait :

pub fn afficher_trait(animal: &impl Animal) { 
    animal.afficher(); 
} 

Cette manière d’écrire la fonction est particulièrement claire. Elle correspond à ce que l’on appelle du sucre syntaxique. Autrement dit, c’est une syntaxe plus intuitive, plus facilement utilisable que la syntaxe en théorie. En effet, en théorie, on l’écrirait ainsi :

pub fn afficher_trait<T: Animal>(animal: &T) { 
    animal.afficher(); 
} 

C’est exactement la même chose : mais comme on le voit...

1. Introduction

Nous sommes ici dans la manière d’écrire les choses. Dans la plupart des cas, le sucre syntaxique est plus pratique pour écrire des passages de traits en paramètres, mais ce n’est pas toujours le cas. En effet, quid des situations où l’on désire un paramètre qui implémente plusieurs traits différents ?

2. Plusieurs traits liés différents pour un même paramètre

pub trait Display { 
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>; 
} 

1. Introduction

Nous avons abordé de façon approfondie le trait en tant que paramètre. Voyons à présent le trait comme valeur de retour d’une fonction. La syntaxe est assez proche de ce que nous avons vu pour le moment, en particulier lorsque nous avons travaillé avec le mot-clé impl.

2. Exemple support

On crée une fonction qui doit nous retourner un objet qui implémente le trait Animal :

fn obtenir_animal(b : bool) -> impl Animal { 
 
    let nom : String = "Mimi l'animal".to_string(); 
    animal::mod_animal::Chien::creer(nom) 
} 

Cette fonction compile et fonctionne. Comme vous pouvez le constater, on indique explicitement que la valeur de retour implémente le trait Animal (impl Animal), mais on se contente de renvoyer une instance de Chien (qui implémente effectivement le trait Animal).

Or, cette solution atteint rapidement ses limites car si la fonction est susceptible de renvoyer des types différents, bien qu’implémentant tous le même trait attendu (Animal ici), la compilation échouera.

En effet, si on écrit ceci :

fn obtenir_animal(b : bool) -> impl Animal { 
 
    let nom : String = "Mimi l'animal".to_string(); 
    if b == true { ...

1. Traits, génériques et structures

Selon le contexte fonctionnel et ce que l’on souhaite faire, nous avons à présent plusieurs manières de proposer une architecture impliquant traits et génériques.

Imaginons un trait nous permettant de définir une course cycliste d’un jour :

// Course d'un jour. 
trait course_jour { 
 
} 

On aura alors plusieurs structures à même d’implémenter ce trait. On peut imaginer les structures ParisRoubaix, ParisTroyes, RedonRedon, etc.

Fort de cette première définition, on se dit que l’on peut construire à présent une structure à même d’accueillir une course par étapes. Pour cela, la structure inclurait un vecteur contenant chaque étape. Comment peut-on combiner la structure Course par étapes avec le trait Course d’un jour ?

Première proposition :

// Course par étapes. 
struct course_étapes<J : course_jour> { 
   etapes : Vec<J> 
}  

On a un vecteur contenant plusieurs courses, mais toujours issues de la même structure. Ce n’est pas idéal d’avoir n fois Paris-Auxerre à courir. En effet, on a forcément dans notre vecteur uniquement des instances d’une même structure. ...