The Rust Programming Language

Annexe A : mots-clés

Les listes suivantes contiennent des mots-clés réservés qui sont actuellement utilisés dans le langage Rust ou qui pourraient l’être à l’avenir. De ce fait, ils ne peuvent pas être utilisés comme identificateurs (sauf comme identificateurs bruts, ce que nous allons voir dans la section “Les identificateurs bruts”. Les identificateurs sont les noms de fonctions, de variables, de paramètres, de champs de structures, de modules, de crates, de constantes, de macros, de valeurs statiques, d’attributs, de types, de traits ou de durées de vie.

Les mots-clés actuellement utilisés

Les mots-clés suivants ont actuellement la fonction décrite.

• as : effectue une transformation de type primitive, précise le trait qui contient un élément ou renomme des éléments dans les instructions use
• async : retourne un Future plutôt que de bloquer la tâche en cours
• await : met en pause l’exécution jusqu’à ce que le résultat d’un Future soit disponible
• break : sort immédiatement d’une boucle
• const : définit des éléments constants ou des pointeurs bruts constants
• continue : passe directement à la prochaine itération de la boucle en cours
• crate : dans un chemin de module, désigne la crate racine (root)
• dyn : utilisation dynamique d’un objet trait
• else : une branche de repli pour les structures de contrôle de flux if et if let
• enum : définit une énumération
• extern : crée un lien vers une crate, une fonction ou une variable externe
• false : le littéral qui vaut “faux” pour un booléen
• fn : définit une fonction ou le type pointeur de fonction
• for : crée une boucle sur les éléments d’un itérateur, implémente un trait, ou renseigne une durée de vie de niveau supérieur
• if : une branche liée au résultat d’une expression conditionnelle
• impl : implémente des fonctionnalités propres à un élément ou à un trait
• in : fait partie de la syntaxe de la boucle for
• let : lie une valeur à une variable
• loop : fait une boucle sans condition (théoriquement infinie)
• match : compare une valeur à des motifs
• mod : définit un module
• move : fait en sorte qu’une fermeture prenne possession de tout ce qu’elle utilise
• mut : autorise la mutabilité sur des références, des pointeurs bruts ou des éléments issus de motifs
• pub : autorise la visibilité publique sur des champs de structures, des blocs impl ou des modules
• ref : lie une valeur avec une référence
• return : retourne une valeur depuis une fonction
• Self : un alias de type pour le type que nous définissons ou implémentons
• self : désigne le sujet d’une méthode ou du module courant
• static : une variable globale ou une durée de vie qui persiste tout au long de l’exécution du programme
• struct : définit une structure
• super : le module parent du module courant
• trait : définit un trait
• true : le littéral qui vaut “vrai” pour un booléen
• type : définit un alias de type ou un type associé
• union : définit une union mais n’est un mot-clé que lorsqu’il est utilisé dans la déclaration d’une union
• unsafe : autorise du code, des fonctions, des traits ou des implémentations non sécurisées
• use : importe des éléments dans la portée
• where : indique des conditions pour contraindre un type
• while : crée une boucle en fonction des résultats d’une expression

Les mots-clés réservés pour une utilisation future

Les mots-clés suivants n’offrent pas encore de fonctionnalités mais sont réservés par Rust pour une possible utilisation future.

• abstract
• become
• box
• do
• final
• gen
• macro
• override
• priv
• try
• typeof
• unsized
• virtual
• yield

Les identificateurs bruts

Les identificateurs bruts sont la syntaxe qui vous permet d’utiliser des mots-clés là où ils ne devraient pas normalement pouvoir l’être. Vous pouvez utiliser un identificateur brut en faisant précéder un mot-clé par un r#.

Par exemple, match est un mot-clé. Si vous essayez de compiler la fonction suivante qui utilise match comme nom :

Fichier : src/main.rs

fn match(aiguille: &str, botte_de_foin: &str) -> bool {
    botte_de_foin.contains(aiguille)
}

… vous allez obtenir l’erreur suivante :

error: expected identifier, found keyword `match`
 --> src/main.rs:4:4
  |
4 | fn match(aiguille: &str, botte_de_foin: &str) -> bool {
  |    ^^^^^ expected identifier, found keyword

L’erreur montre que vous ne pouvez pas utiliser le mot-clé match comme identificateur de la fonction. Pour utiliser match comme nom de fonction, vous devez utiliser la syntaxe d’identificateur brut, comme ceci :

Fichier : src/main.rs

fn r#match(aiguille: &str, botte_de_foin: &str) -> bool {
    botte_de_foin.contains(aiguille)
}

fn main() {
    assert!(r#match("rem", "lorem ipsum"));
}

Ce code va se compiler sans erreur. Remarquez le préfixe r# sur le nom de la fonction dans sa définition mais aussi lorsque cette fonction est appelée dans main.

Les identificateurs bruts vous permettent d’utiliser n’importe quel mot de votre choix comme identificateur, même si ce mot est un mot-clé réservé. Ceci nous octroie plus de liberté pour choisir des noms d’identifiants, et cela permet aussi de s’intégrer avec des programmes écrits dans un autre langage où ces mots ne sont pas des mots-clés. De plus, les identificateurs bruts vous permettent d’utiliser des bibliothèques écrites dans des éditions de Rust différentes de celle qu’utilise votre crate. Par exemple, try n’est pas un mot-clé dans l’édition 2015, mais il l’est dans les éditions 2018, 2021 et 2024. Si vous dépendez d’une bibliothèque qui était écrite avec l’édition 2015 et qui avait une fonction try, vous devrez alors utiliser la syntaxe d’identificateur brut, r#try dans ce cas, pour faire appel à cette fonction à partir de votre code écrit avec des éditions ultérieures. Voir l’annexe E pour en savoir plus sur les éditions.