Réponse.

Historique de la question

Dans le langage Rust, comme dans de nombreux langages de programmation modernes, un système d'inférence de type est implémenté, ce qui aide le programmeur à économiser du temps et à réduire la quantité de code dupliqué. Il est apparu dans Rust presque dès le début, afin de faciliter la typage statique sans avoir à spécifier explicitement le type d'une variable à chaque fois.

Problème

Bien que l'inférence de type accélère le travail et rend le code plus concis, son utilisation trop fréquente ou non contrôlée peut entraîner des erreurs non évidentes, une lisibilité réduite et des problèmes de performance inattendus. Dans tous les cas, le compilateur peut ne pas être capable de déduire correctement ou de manière univoque le type. Certaines constructions de Rust nécessitent des annotations explicites, sinon le code ne pourra pas être compilé.

Solution

Rust prend en charge l'inférence de type locale (portée locale) et contextuelle. Le plus souvent, l'inférence de type fonctionne pour des variables, des valeurs retournées par des fonctions, ainsi que pour des expressions let à l'intérieur des fonctions. Dans tous les autres cas (par exemple, lors de la déclaration de structures, de signatures de fonctions, de fonctions génériques), les types doivent être spécifiés.

Exemple de code :

let x = 10; // x: i32 (par défaut)
let y = vec!["hello", "world"]; // y: Vec<&str>

fn add<T: std::ops::Add<Output = T>>(a: T, b: T) -> T {
    a + b
}
let sum = add(2u16, 3u16); // sum: u16

Caractéristiques clés :

Rust ne fait d'inférence de type que dans une portée limitée, par l'expression à droite du signe =.
Les annotations de type sont obligatoires dans les API publiques, le code générique, les structures et les traits.
Des types peu évidents ou trop "généraux" nuisent à la lisibilité et à la maintenance du code, même si le compilateur les déduit.

Questions pièges.

Le compilateur Rust peut-il déduire le type d'une fonction si la valeur de retour n'est pas spécifiée explicitement ?

Non, dans la signature de la fonction, le type de la valeur retournée doit toujours être spécifié explicitement, sinon il y aura une erreur de compilation.

// Il y aura une erreur :
fn func() { 42 }
// Cela doit être ainsi :
fn func() -> i32 { 42 }

Peut-on se fier entièrement à l'inférence de type lors de l'utilisation de collections ou de références ?

Il est souvent nécessaire d'avoir une annotation explicite, en particulier avec des références mutables/immuables et des collections génériques complexes, pour éviter les ambiguïtés ou obtenir le type souhaité.

let data = Vec::new(); // data: Vec<()> — type pas toujours attendu
let numbers: Vec<i32> = Vec::new(); // spécifié explicitement

Comment l'inférence de type fonctionne-t-elle lors de l'utilisation de closures et de paramètres de fonction ?

Le compilateur peut inférer les types des paramètres de la closure par le contexte, mais pas toujours — parfois une annotation complète sera nécessaire.

let plus_one = |x| x + 1; // erreur : impossible de déduire le type x
let plus_one = |x: i32| x + 1; // se compile

Erreurs typiques et anti-patterns

Une dépendance totale à l'inférence de type sans types explicites dans du code complexe entraîne une salissure du code par des erreurs, une mauvaise maintenance et une lisibilité réduite.
L'utilisation de Vec::new() ou de HashMap::new() sans paramètres génériques explicites donne souvent des résultats inattendus.

Exemple de la vie réelle

Cas négatif

Un développeur a écrit une fonction API avec des paramètres et des variables locales entièrement non annotés, tout le code reposant uniquement sur l'inférence de type. L'équipe a rencontré de nombreuses erreurs personnalisées et de la confusion: il n'était pas clair quels types étaient attendus par les paramètres et ce que la fonction retournait réellement.

Avantages :

Moins de code
Développement rapide d'un prototype simple

Inconvénients :

Documentation API très pauvre
Erreurs lors de la modification du code
Difficulté de débogage

Cas positif

Une autre équipe a utilisé l'inférence de type uniquement pour des variables locales dans des expressions simples, et pour toutes les API publiques, structures génériques et fonctions, a toujours spécifié les types de manière explicite. En conséquence, la maintenance et la compréhension du code se sont nettement améliorées, réduisant le nombre de bugs.