Sintaxis de Rust

Ahora que ya puedes ejecutar Rust, vamos a ir más despacio y ver qué significa cada parte de un programa. Usaremos el ejemplo más pequeño posible y lo desarmaremos pieza por pieza.

fn main() {
    println!("¡Hola, mundo!");
}

Salida:

¡Hola, mundo!

▶ Pruébalo tú mismo

La función main

fn main() {
    // aquí se ejecuta tu código
}

Todo programa de Rust empieza en una función llamada main. Cuando ejecutas tu programa, Rust busca main y ejecuta el código que hay dentro.

• fn es la palabra clave para definir una función (un bloque de código con nombre).
• main es el nombre de la función. Este nombre en concreto es especial: es el punto de entrada.
• () contiene las entradas de la función (aquí está vacío: main no recibe ninguna).
• Las llaves { } envuelven el cuerpo, es decir, el código que pertenece a la función.

Las sentencias terminan con punto y coma

Dentro del cuerpo, cada instrucción suele ser una sentencia, y las sentencias terminan con un punto y coma ;:

fn main() {
    let x = 5;
    let y = 10;
    println!("{}", x + y);
}

Salida:

15

▶ Pruébalo tú mismo

Olvidar un punto y coma donde hace falta es uno de los errores más comunes al empezar. Tranquilo: el compilador te señalará exactamente dónde falta.

Expresiones: código que devuelve un valor

El código de Rust está hecho de dos tipos de piezas, y la diferencia importa más en Rust que en la mayoría de los lenguajes:

• Una sentencia hace algo, pero no devuelve ningún valor. let x = 5; es una sentencia.
• Una expresión produce un valor. 5, x + 1 y x * 2 son expresiones.

Esta es la parte que sorprende: un bloque de código entre llaves { } también es una expresión. Su valor es la última línea, escrita sin punto y coma:

fn main() {
    let x = 5;
    let y = {
        let doubled = x * 2; // una sentencia dentro del bloque
        doubled + 1          // sin punto y coma: este es el valor del bloque
    };
    println!("y vale {y}");
}

Salida:

y vale 11

▶ Pruébalo tú mismo

El bloque ejecuta sus sentencias y luego devuelve doubled + 1, que es 11, y ese valor pasa a ser y. Fíjate en el punto y coma después de la } final: la línea completa let y = ...; sigue siendo una sentencia.

Si añades un punto y coma después de doubled + 1, deja de ser el valor del bloque. Entonces el bloque devuelve “nada” (Rust lo escribe como ()), y println! no puede mostrarlo, así que el código no compila. Esta regla de “sin punto y coma en la última línea” es justamente la forma en que las funciones devuelven valores. La verás otra vez en la página de Funciones y con if como expresión.

Las macros y el !

Fíjate bien en println!: ese signo de exclamación no es un error de tipeo. El ! significa que es una macro (código que genera código), no una función normal.

Todavía no necesitas entender las macros a fondo. Solo recuerda esto: cuando veas !, es una macro. Por ahora, la única que vas a usar es println! para mostrar texto.

fn main() {
    println!("Esto es una llamada a una macro");
}

Nota

La diferencia entre una función y una macro importa más adelante. Como principiante, solo recuerda que println!, format! y vec! llevan ! porque son macros. Las funciones normales, como main(), no lo llevan.

Mostrar valores con {}

Dentro de println!, las llaves {} son marcadores de posición que se rellenan con los valores que pasas después del texto:

fn main() {
    let name = "Ferris";
    let age = 10;
    println!("{} tiene {} años", name, age);
}

Salida:

Ferris tiene 10 años

▶ Pruébalo tú mismo

También puedes poner el nombre de la variable directamente dentro de las llaves, y muchas veces queda más limpio:

println!("{name} tiene {age} años");

Espacios e indentación

A Rust no le importa la indentación como a Python. Usa las llaves { } para saber dónde empieza y dónde termina cada bloque. La indentación es solo para que las personas lean el código con más facilidad.

Aun así, la comunidad tiene un estilo estándar, y Rust incluye una herramienta que lo aplica automáticamente:

cargo fmt

Al ejecutar cargo fmt, tu código se reformatea con el estilo oficial. Acostúmbrate a usarlo.

Comentarios

Puedes dejar notas en tu código que Rust ignora. Se llaman comentarios y empiezan con //:

fn main() {
    // Esto es un comentario: Rust lo salta
    println!("¡Hola!"); // los comentarios también pueden ir al final de una línea
}

Veremos los comentarios con más detalle en la próxima página.

Práctica

1. Muestra la cuenta

Crea dos variables, a = 7 y b = 3, e imprime 7 + 3 = 10. Deja que Rust haga la suma. Pista: un println! puede tener varios marcadores {}, que se rellenan en orden con los valores que van después del texto.

Ver solución

fn main() {
    let a = 7;
    let b = 3;
    println!("{} + {} = {}", a, b, a + b);
}

Salida:

7 + 3 = 10

▶ Pruébalo tú mismo

2. Un bloque que calcula un total

Una tienda vende 3 artículos a 4 cada uno, más 2 de envío. Calcula total con un bloque { }: dentro, crea un subtotal y luego devuelve subtotal + 2. Imprime Total: 14. Pista: la última línea del bloque no debe llevar punto y coma.

Ver solución

fn main() {
    let price = 4;
    let quantity = 3;
    let total = {
        let subtotal = price * quantity;
        subtotal + 2 // envío
    };
    println!("Total: {total}");
}

Salida:

Total: 14

▶ Pruébalo tú mismo

Resumen

• Todo programa empieza en la función main.
• El código va dentro de llaves { }, y la mayoría de las sentencias terminan con ;.
• Las sentencias hacen algo; las expresiones producen un valor. La última línea de un bloque sin ; es su valor.
• Un ! (como en println!) significa que es una macro.
• Las {} dentro de println! son marcadores de posición que se rellenan con los valores que pasas.
• La indentación es para que el código se lea mejor. Ejecuta cargo fmt para formatearlo automáticamente.

Comprueba lo que aprendiste

Comprueba lo aprendido

1. ¿Qué tiene de especial la función main en un programa de Rust?

Es el punto de entrada donde empieza la ejecución Siempre tiene que devolver un valor Tiene que ser la primera función del archivo

2. ¿Qué significa el ! después de println?

Niega la salida Que es una macro, no una función normal Es un error de sintaxis

3. ¿Cuál es el valor de y después de let y = { let a = 2; a + 1 };?

2 3 Ninguno, porque los bloques no pueden tener un valor

Puntuación: 0 / 3

Para leer más

• Anatomy of a Rust Program: The Rust Book (en inglés): el recorrido oficial por fn main, println! y los puntos y coma.
• Statements and Expressions: The Rust Book (en inglés): más ejemplos de la diferencia entre sentencias y expresiones, incluidos los bloques.
• Hello World: Rust by Example (en inglés): un programa diminuto que puedes ejecutar, y cómo compilarlo directamente con rustc.
• Expressions: Rust by Example (en inglés): ejemplos cortos de bloques usados como valores, y qué pasa con un punto y coma al final.
• Statements and expressions: The Rust Reference (en inglés): las reglas precisas y formales, para cuando tengas curiosidad más adelante.