Réponse.

Historique de la question

Dans de nombreux langages de programmation populaires, tels que C ou JavaScript, les variables sont mutables par défaut. En Rust, les auteurs du langage ont fait un choix important en faveur de l'immuabilité des variables par défaut : cette décision est liée à la sécurité du code et à la réduction des erreurs causées par des modifications inattendues de l'état des variables.

Problème

Le principal problème des variables mutables est la complexité du débogage et de la recherche des erreurs liées aux modifications implicites des valeurs. Il est particulièrement difficile de comprendre le comportement du code lorsque les variables changent à différents endroits du programme et que le contrôle de leurs modifications est perdu. Cela peut conduire à des bogues et à des résultats inattendus, en particulier lors de l'écriture d'applications multithread ou lors de dépendances complexes dans le code.

Solution

Dans Rust, les variables sont immuables par défaut à l'aide du mot clé let. Pour rendre une variable mutable, il faut explicitement spécifier mut. Cela augmente la fiabilité du code, rend l'immuabilité un choix conscient et réduit la probabilité de modifications accidentelles.

Exemple de code :

let x = 5;        // variable immuable
let mut y = 10;   // variable mutable
y += 1;           // correct
x += 1;           // erreur de compilation !

Caractéristiques clés :

Immutabilité par défaut — pour la sécurité.
Indication explicite de mutabilité par mut.
Le compilateur empêche les modifications des variables immuables lors de la compilation.

Questions piégées.

Peut-on modifier un champ d'une structure si la variable de la structure est déclarée comme immuable ?

Non, si la variable de la structure est déclarée comme immuable, ses champs sont également immuables. Pour modifier les champs, il faut déclarer la variable avec mut.

Exemple de code :

struct Point { x: i32, y: i32 }
let mut p = Point { x: 0, y: 0 };
p.x = 5; // ok
let p2 = Point { x: 1, y: 2 };
p2.x = 3; // erreur de compilation !

Si la variable est mut, peut-on y référencer plusieurs références mutables en même temps ?

Non, en Rust, il ne peut y avoir qu'une seule référence mutable à un objet à la fois. Cette règle prévient les conditions de course des données.

Peut-on déclarer un tableau d'objets immuables comme mutable et modifier son contenu ?

Oui. Si la variable du tableau est déclarée comme mut, ses éléments peuvent être modifiés, mais si le contenu du type de tableau ne supporte pas la mutabilité, alors les éléments ne sont pas mutables.

Erreurs typiques et anti-patterns

Utilisation de mut sans nécessité, rendant le code moins sécurisé.
Tentative de modification du contenu d'une variable sans déclaration mut.
Malentendus avec la mutabilité des structures imbriquées.

Exemple de la vie réelle

Cas négatif

Dans un projet, les variables sont déclarées mutables par habitude, même quand cela n'est pas nécessaire. À cause de cela, une des variables est accidentellement modifiée au milieu du programme par une autre méthode, ce qui entraîne une erreur difficile à détecter en production.

Avantages :

Rapidité d'écriture du code sans avoir besoin de suivre la mutabilité.

Inconvénients :

Complexité du débogage et risque élevé de bogues dus à des modifications indésirables.

Cas positif

Dans un projet d'équipe, une règle est suivie : par défaut, les variables sont immuables, et la mutabilité n'est utilisée que là où cela est absolument nécessaire, toujours en ajoutant des commentaires expliquant la raison.