Inferencia de tipos

Parte de la sección Fundamentals del Journey de Rust de Coddy — lección 12 de 75.

En Rust, la inferencia de tipos permite al compilador deducir automáticamente el tipo de una variable basándose en su valor y uso. Esto significa que a menudo no es necesario especificar explícitamente el tipo al declarar una variable, haciendo que su código sea más conciso y fácil de leer.

Por ejemplo:

let x = 5;
// Rust infiere que x es un i32

let y = 3.14;
// Rust infiere que y es un f64

let message = "Hello, world!";
// Rust infiere que message es un &str (cadena)

let is_true = true;
// Rust infiere que is_true es un bool

En estos ejemplos, no especificamos los tipos de x, y, message y is_true. El compilador de Rust infirió automáticamente sus tipos basándose en los valores que se les asignaron.

La inferencia de tipos no solo es conveniente, sino que también ayuda a prevenir errores. El compilador comprueba cómo se utilizan las variables y garantiza que los tipos inferidos sean coherentes en todo el código. Si hay un conflicto, el compilador generará un error.

Desafío

Principiante

Escribe un programa en Rust que demuestre la inferencia de tipos. Declara e inicializa las siguientes variables sin anotaciones de tipo explícitas:

Una variable llamada quantity con el valor 10.
Una variable llamada price con el valor 99.99.
Una variable llamada message con el valor "Coddy is awesome!".
Una variable llamada is_available con el valor true.

Después de declarar estas variables, usa println!() para mostrar sus valores en la consola. Observa cómo Rust infiere los tipos de estas variables basándose en sus valores.

Hoja de referencia

La inferencia de tipos de Rust permite que el compilador deduzca automáticamente los tipos de variables basándose en sus valores, eliminando la necesidad de anotaciones de tipo explícitas en muchos casos.

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

El compilador verifica el uso de las variables para asegurar la consistencia de tipos y generará errores si existen conflictos.

Pruébalo tú mismo

fn main() {
    // Declarar variables aquí
    
    
    // Mostrar los valores
    println!("Quantity: {}", quantity);
    println!("Price: {}", price);
    println!("Message: {}", message);
    println!("Is available: {}", is_available);
}