Saga écrite par Benoît Prieur

Série estivale en six épisodes, à raison d’une publication par semaine. Sans prérequis particulier : de quoi comprendre les principes de la programmation moderne à travers l’exemple de Rust, un langage en pleine progression.

Tout programme repose sur des variables. Une variable est simplement une boîte étiquetée dans laquelle on range une information pour la retrouver plus tard : une boîte « âge » contenant 42, une boîte « prénom » contenant « Ada ». Programmer consiste en grande partie à remplir, lire et modifier ces boîtes.

Une question distingue les langages entre eux : faut-il préciser à l’avance ce que chaque boîte a le droit de contenir ?

Dans un langage à typage dynamique, on ne précise rien. Une même boîte peut contenir successivement un nombre, une phrase, puis une liste. C’est souple et rapide à écrire. L’inconvénient apparaît plus tard : si l’on tente par erreur d’additionner un nombre et une phrase, rien ne le signale à l’avance, et le problème ne se révèle qu’en cours d’exécution. Python et JavaScript relèvent de cette catégorie.

Dans un langage à typage statique, chaque boîte porte une étiquette qui annonce son contenu : celle-ci ne recevra que des nombres entiers, celle-là que du texte. Le compilateur vérifie la cohérence avant que le programme ne tourne. L’addition d’un nombre et d’une phrase est alors rejetée d’emblée. C’est plus contraignant, mais plus sûr. Rust, comme le C ou Java, appartient à cette famille.

On peut comparer le typage statique aux jeux d’encastrement pour enfants, où une forme ne rentre que dans le trou correspondant. Le contrôle empêche d’assembler des pièces incompatibles, au prix d’une rigueur imposée dès le départ.

Rust est rigoureux sur ce point, mais il n’impose pas d’alourdir le code. Il est capable de déduire le type tout seul. Si l’on écrit :

let age = 42;

Aucun type n’est indiqué, et pourtant le compilateur comprend que 42 est un nombre entier et fixe la boîte age sur ce type. Ce mécanisme, appelé inférence de type, combine la légèreté d’écriture des langages souples et la sécurité des langages stricts : on bénéficie des vérifications sans avoir à tout déclarer à la main.

Rust adopte par ailleurs une convention à contre-courant. Dans la plupart des langages, une variable est modifiable par défaut. En Rust, c’est l’inverse : une fois remplie, une boîte conserve son contenu, à moins d’avoir explicitement demandé de pouvoir le changer :

let mut glaces = 2;

glaces = 3;

Le mot-clé mut, pour « mutable », signale cette intention. Cette contrainte volontaire encourage à ne rendre modifiable que ce qui doit l’être. Une donnée qui change sans que le programmeur l’ait prévu est une source classique d’erreurs ; en faisant de l’immuabilité la règle et du changement l’exception, Rust en écarte toute une catégorie.

Une boîte qui déduit son contenu et le conserve tant qu’on n’a pas autorisé sa modification : ce comportement résume l’orientation du langage, plus soucieux de prévenir les erreurs que de faciliter les raccourcis.

Le prochain épisode aborde la notion la plus caractéristique de Rust, la possession : la manière dont le langage résout, sans dispositif automatique, la question de la libération de la mémoire.