Réponse.

Historiquement, l'un des principes de Rust était de garantir la sécurité des types et l'absence de conversions implicites menant à des erreurs d'exécution. Cependant, pour faciliter le code, des conversions automatiques partielles sont mises en œuvre via deref coercion et les traits From/Into, afin de simplifier le travail avec des références, des pointeurs intelligents et de permettre des API universelles.

Le problème survient lorsque les conversions automatiques peuvent causer de la confusion, par exemple lors du passage d'un &String là où un &str est attendu. Cela invoque un Deref::deref caché, entraînant parfois des conséquences imprévues (par exemple, lors de la modification du type des paramètres passés). Il y a également la question du casting direct et explicite via as.

Solution : Rust implémente des règles strictes de deref-coercion pour les pointeurs intelligents (Box, Rc, Arc) et les chaînes (&String vers &str, &Vec vers &slice) au niveau du compilateur. Pour les conversions explicites, des traits tels que From, Into, TryFrom, TryInto et as pour les casts de base sont prévus. L'évitement des erreurs est aidé par la typage statique et la limitation des conversions implicites.

Exemple de code :

fn print_text(text: &str) {
    println!("{}", text);
}

let s = String::from("Hello!");
print_text(&s); // s: String, &s: &String, conversion automatique vers &str

Caractéristiques clés :

La deref coercion se déclenche lorsqu'une fonction/méthode est appelée avec un type de référence.
Les conversions explicites de type via les traits From/Into pour des conversions sécurisées.
as est approprié uniquement pour les types primitifs, sinon un comportement incorrect peut survenir.

Questions pièges.

La deref coercion fonctionne-t-elle pour les types définis par l'utilisateur si Deref est implémenté manuellement ?

Oui, si vous implémentez le trait Deref pour votre type, le compilateur pourra convertir automatiquement votre wrapper en type cible au sein de la signature de la fonction qui attend la référence correspondante.

La deref coercion peut-elle se produire pour des valeurs, et non pour des références ?

Non, le désajustement automatique se produit uniquement lors du passage de références, et seulement quand le type implémente Deref.

Quelles sont les limitations de la conversion de types via as lors de la manipulation de nombres et d'enums ?

as ne garantit pas la sécurité : la conversion entre types numériques peut entraîner un débordement ou une perte de données, et pour les enums, cela peut entraîner des valeurs non sémantiques (par exemple, une variante enum incorrecte).

Erreurs typiques et anti-patterns

Attendre une conversion implicite là où Rust ne le fait pas : des concaténations de chaînes via + sans conversion vers &str.
Utilisation de as entre des types incompatibles (par exemple, il est impossible de convertir directement &str en &String).
Clonage explicite lors du passage de références, lorsque deref coercion suffit.

Exemple de la vie réelle

Cas négatif

Un débutant écrit une fonction prenant &String et ne peut pas utiliser &str directement, faisant text.to_string() partout. Cela consomme inutilement de la mémoire et des performances.

Avantages :

Compréhension explicite que la fonction travaille avec String.

Inconvénients :

Allocations inutiles, perte de l'universalité de l'API, complexité dans la maintenance.

Cas positif

La fonction prend un argument de type &str, permettant d'être appelée avec n'importe quel type supportant le désajustement ou la conversion : &str, &String, littéraux de chaîne. Pas d'allocations supplémentaires requises.