Inférence de type

Fait partie de la section Fundamentals du Journey Rust de Coddy — leçon 12 sur 75.

En Rust, l'inférence de type permet au compilateur de déduire automatiquement le type d'une variable en fonction de sa valeur et de son utilisation. Cela signifie que vous n'avez souvent pas besoin de spécifier explicitement le type lors de la déclaration d'une variable, rendant votre code plus concis et plus facile à lire.

Par exemple :

let x = 5;
// Rust déduit que x est un i32

let y = 3.14;
// Rust déduit que y est un f64

let message = "Hello, world!";
// Rust déduit que message est un &str (chaîne de caractères)

let is_true = true;
// Rust déduit que is_true est un bool

Dans ces exemples, nous n'avons pas spécifié les types de x, y, message et is_true. Le compilateur Rust a automatiquement inféré leurs types en fonction des valeurs qui leur ont été assignées.

L'inférence de type est non seulement pratique, mais elle aide également à prévenir les erreurs. Le compilateur vérifie comment les variables sont utilisées et s'assure que les types inférés sont cohérents dans tout le code. S'il y a un conflit, le compilateur générera une erreur.

Défi

Débutant

Écrivez un programme Rust qui démontre l'inférence de type. Déclarez et initialisez les variables suivantes sans annotations de type explicites :

Une variable nommée quantity avec la valeur 10.
Une variable nommée price avec la valeur 99.99.
Une variable nommée message avec la valeur "Coddy is awesome!".
Une variable nommée is_available avec la valeur true.

Après avoir déclaré ces variables, utilisez println!() pour afficher leurs valeurs dans la console. Observez comment Rust infère les types de ces variables en fonction de leurs valeurs.

Aide-mémoire

L'inférence de type de Rust permet au compilateur de déduire automatiquement les types de variables en fonction de leurs valeurs, éliminant ainsi le besoin d'annotations de type explicites dans de nombreux cas.

let x = 5;        // Rust infère i32
let y = 3.14;     // Rust infère f64
let message = "Hello, world!";  // Rust infère &str
let is_true = true;  // Rust infère bool

Le compilateur vérifie l'utilisation des variables pour garantir la cohérence des types et générera des erreurs en cas de conflits.

Essayez vous-même

fn main() {
    // Déclarer les variables ici
    
    
    // Afficher les valeurs
    println!("Quantity: {}", quantity);
    println!("Price: {}", price);
    println!("Message: {}", message);
    println!("Is available: {}", is_available);
}