Macros básicas

Cuatro macros que ya has visto, ahora explicadas

Ya escribiste println! en casi cada ejemplo de este curso, y cada ejercicio comprobó tu solución con assert_eq!, sin que se explicara qué son ni por qué llevan !. Esta lección cierra esa cuenta pendiente, y de paso cierra el módulo 1 entero: vec! cumple la promesa que hizo «Variables, mutabilidad y tipos» de mostrar una colección que sí puede crecer.

println!, format!, vec! y assert! son macros, no funciones: por eso llevan !. Una macro se expande en tiempo de compilación, así que puede aceptar un número variable de argumentos y comprobar tu cadena de formato antes de que el programa se ejecute siquiera.

Verás cuatro estaciones, una por macro: println!, format!, vec! y la familia assert!.

LLAMADA · println!macro, no función: nota el !
MACRO · Display vs Debug{scores:?} imprime el array
RESULTADO · salida impresa3 apples · [1, 2, 3]

01 / 04{} · {:?} · {NOMBRE}

{} usa Display; {:?} usa Debug

{} usa el trait Display, pensado para lectura humana; {:?} usa Debug, pensado para depurar, y es el único que funciona con colecciones como arrays. Dentro de las llaves puedes escribir directamente el nombre de una variable, como {count}.

lib.rsCompila↗

fn main() {
    let count = 3;
    println!("{count} apples");

    let scores = [1, 2, 3];
    println!("{scores:?}");
}

Resultado

format! construye un String en vez de imprimir

format! acepta la misma sintaxis que println!, pero en vez de imprimir, devuelve un String. println! usa por dentro el mismo mecanismo de formateo; la diferencia es solo el destino: pantalla o variable.

lib.rsCompila↗

/// `format!` uses the same syntax as `println!` but returns a `String`
/// instead of printing it.
#[must_use]
pub fn greeting(name: &str) -> String {
    format!("Hello, {name}!")
}

// Playground entry point for this example.
fn main() {
    println!("{}", greeting("Ferris"));
}

Resultado

vec! crea un Vec, a diferencia del array de tamaño fijo

Un array tiene tamaño fijo: no puedes añadirle elementos después de crearlo. vec! crea un Vec, una colección que vive en el heap y puede crecer o encogerse en tiempo de ejecución con .push(), .pop(), y más.

vec! crea una colección de tamaño variable; un array literal no.

lib.rsCompila↗

/// `vec!` creates a Vec, a growable collection; unlike an array, its
/// length is not fixed at compile time.
#[must_use]
pub fn grow_scores() -> Vec<i32> {
    let mut scores = vec![10, 20, 30];
    scores.push(40);
    scores
}

// Playground entry point for this example.
fn main() {
    println!("{:?}", grow_scores());
}

Resultado

assert! y assert_eq! exigen Debug para poder explicarse

Ya usaste assert_eq! sin saberlo: cada ejercicio de este curso comprueba tu solución con exactamente esta macro. assert! comprueba una condición; assert_eq! y assert_ne! comparan dos valores, y si la comprobación falla, el mensaje de pánico los imprime con Debug.

lib.rsCompila↗

/// `assert!`, `assert_eq!`, and `assert_ne!` panic with a formatted
/// message when the condition is false; here every check passes silently.
///
/// # Panics
///
/// Panics if any of the three checks fails.
#[must_use]
pub fn checks_pass() -> bool {
    let scores = [10, 20, 30];
    assert!(scores[0] < scores[1]);
    assert_eq!(scores.len(), 3);
    assert_ne!(scores[0], scores[1]);
    true
}

// Playground entry point for this example.
fn main() {
    println!("{}", checks_pass());
}

Resultado

Por eso assert_eq! exige que el tipo implemente Debug: sin él, no hay forma de mostrar el valor que falló.

lib.rsNo compila↗

#[derive(PartialEq)]
struct Point(i32, i32);

fn main() {
    let a = Point(1, 2);
    let b = Point(1, 2);
    assert_eq!(a, b); // ERROR: Point doesn't implement Debug
}

Resultado

El compilador dice (E0277)

`Point` doesn't implement `Debug`. assert_eq! necesita Debug en ambos lados para poder explicar un fallo.

error[E0277]: `Point` doesn't implement `Debug`
--> src/main.rs:7:5
|
7 |     assert_eq!(a, b);
|     ^^^^^^^^^^^^^^^^ the trait `Debug` is not implemented for `Point`
|
= note: add `#[derive(Debug)]` to `Point` or manually `impl Debug for Point`
help: consider annotating `Point` with `#[derive(Debug)]`
|
2 + #[derive(Debug)]
3 | struct Point(i32, i32);
|

.forge-journey { height: auto !important; } .forge-journey__viewport { position: static !important; height: auto !important; display: block !important; } .forge-journey__stage { min-height: auto; overflow: visible; } .forge-journey__fallback { position: static !important; width: auto !important; height: auto !important; margin: 0 !important; clip: auto !important; overflow: visible !important; } .forge-journey__fallback-chapter[hidden] { display: block !important; margin-bottom: 2rem; } .forge-journey__panel { min-height: auto !important; } .forge-journey__chapter { position: static !important; opacity: 1 !important; visibility: visible !important; transform: none !important; border-bottom: 1px solid rgba(255,255,255,.12); } .forge-journey__panel-header, .forge-journey__controls { display: none !important; }

Objetivo

Completa build_report para que devuelva un String con el formato "scores: [a, b, c], total: suma", usando vec!, un for para sumar, y format!.

Implementa

Sustituye `todo!` por `vec![a, b, c]`, un `for` que sume, y `format!` con `{scores:?}` y `{sum}`.

Agrupa los tres valores en un Vec, súmalos con un for, y formatea el resultado con format!.

pub fn build_report(a: i32, b: i32, c: i32) -> String {
    todo!("build a Vec with vec![a, b, c], sum it with a for loop, and format the result")
}

Comprueba

Ejecuta los casos visibles y usa el diagnóstico para corregir el código.

Pruebas visibles

produce el texto exacto para valores positivos y negativos

Compilador—

Modifica el código antes de ejecutar las pruebas.

Ayuda

Consulta pistas progresivas o compara con la solución.

Solución comentadaSolución↗

/// Builds a report string from three scores using vec! and format!.
#[must_use]
pub fn build_report(a: i32, b: i32, c: i32) -> String {
    let scores = vec![a, b, c];
    let mut sum = 0;

    for score in &scores {
        sum += score;
    }

    format!("scores: {scores:?}, total: {sum}")
}

// Playground entry point for this example.
fn main() {
    println!("{}", build_report(10, 20, 30));
}

Resultado

Resumen

println!, format!, vec! y assert! son macros, no funciones: por eso llevan !.
{} usa Display (lectura humana); {:?} usa Debug (depuración), y es el único que funciona con colecciones.
format! construye un String con la misma sintaxis que println!, sin imprimir nada.
vec! crea un Vec de tamaño variable; a diferencia de un array, admite .push() y .pop().
assert!, assert_eq! y assert_ne! hacen panic! con un mensaje formateado cuando la comprobación falla.
assert_eq!/assert_ne! exigen que el tipo implemente Debug, para poder imprimir ambos lados si fallan.

Fuentes

The Rust Programming Languagech08-01 · Klabnik, Nichols, Krycho y la comunidad de Rust
Rust by Examplehello/print
Comprehensive Rustbasic-syntax/println · Geisler y colaboradores (Google)

Cuatro macros que ya has visto, ahora explicadas

Construye un informe con vec! y format!.

Implementa

Construir el informe

Comprueba

Ayuda

Resumen

Fuentes