Imprimiendo Vec en Rust: de principiante a profesional

«¿Cómo imprimir un Vec?» — la pregunta que todo desarrollador de Rust se ha hecho

Si alguna vez has escrito en Rust y has intentado simplemente imprimir un vector en pantalla, seguramente te has encontrado con esto:

fn main() {\n    let numbers = vec![1, 2, 3, 4, 5];\n    println!("{}", numbers); // ¡Error!\n}

El compilador te recibe con un mensaje rojo: `Vec<{integer}>` doesn't implement `std::fmt::Display`. ¿Te suena? Esta pregunta en Stack Overflow ha acumulado miles de visitas, y no es casualidad. En Rust no hay «magia»: el compilador exige que especifiques cómo exactamente quieres mostrar la colección. Y esto es maravilloso, porque te da control total.

En este artículo analizaremos todas las formas principales de imprimir un Vec en Rust: desde la salida de depuración rápida hasta la creación de un formateo bonito para el usuario. Aprenderás qué método usar en cada caso y dejarás de temer los errores de compilación.

¿Por qué Vec no implementa Display?

Antes de lanzarnos al código, entendamos la filosofía de Rust. El trait Display está diseñado para mostrar datos al usuario — tal como quieres verlos en la interfaz. Y Debug es para depuración y registros.

Para un vector es imposible adivinar qué formato necesitas:

\n
• ¿Mostrar los elementos separados por comas?
\n
• ¿Cada elemento en una nueva línea?
\n
• ¿Entre corchetes, como un arreglo?
\n
• ¿O en forma de tabla?
\n

Por eso, los desarrolladores de Rust decidieron no imponer un formato único, sino dejar la elección al programador. Veamos qué opciones tenemos.

Forma 1: Salida de depuración rápida (Debug)

La forma más sencilla es usar {:?} o {:#?} (pretty-print). Para esto, el tipo de los elementos del vector debe implementar el trait Debug.

fn main() {\n    let numbers = vec![1, 2, 3, 4, 5];\n    println!("{:?}", numbers);    // [1, 2, 3, 4, 5]\n    println!("{:#?}", numbers);   // Salida bonita:\n                                  // [\n                                  //     1,\n                                  //     2,\n                                  //     3,\n                                  //     4,\n                                  //     5\n                                  // ]\n}

Cuándo usarlo: depuración, registro de logs, verificación rápida. Generalmente no es adecuado para producción — el formato no es flexible.

Importante: si tu tipo no implementa Debug, el compilador te lo indicará. Para tus propias estructuras puedes agregar #[derive(Debug)]:

#[derive(Debug)]\nstruct Point {\n    x: f64,\n    y: f64,\n}\n\nfn main() {\n    let points = vec![Point { x: 1.0, y: 2.0 }, Point { x: 3.0, y: 4.0 }];\n    println!("{:?}", points);\n}

Forma 2: Iteración manual con iterador

La forma más flexible es escribir tu propio bucle. Obtienes control total sobre el formato.

fn main() {\n    let words = vec!["hello", "world", "rust"];\n    \n    // Opción 1: separados por comas\n    for (i, word) in words.iter().enumerate() {\n        if i > 0 {\n            print!(", ");\n        }\n        print!("{}", word);\n    }\n    println!(); // hello, world, rust\n\n    // Opción 2: cada uno en una nueva línea\n    for word in &words {\n        println!("- {}", word);\n    }\n    // - hello\n    // - world\n    // - rust\n}

Este enfoque ofrece la máxima flexibilidad, pero requiere más código. Es ideal cuando necesitas un formateo único.

Forma 3: Uso de iterador con collect y join

Si solo necesitas unir los elementos en una cadena, puedes usar join del trait SliceConcatExt (disponible para slices):

fn main() {\n    let words = vec!["hello", "world", "rust"];\n    let joined = words.join(", ");\n    println!("{}", joined); //