La visualización y depuración

Puedes ver este capítulo en YouTube en inglés

En Rust, las variables simples se pueden imprimir usyo {} en println!. Pero hay variables que no pueden imprimirse y es necesario usar la impresión de depuración. La impresión de depuración es para los programadores, porque habitualmente muestra más información. En ocasiones, esta impresión no es "bonita", no queda bien, porque muestra información extra para ayudarte.

¿Cómo puedes conocer si necesitas usar {:?} y no {}? El compilador te avesará. Por ejemplo:

fn main() {
    let no_imprime = ();
    println!("Esto no se imprimirá: {}", no_imprime); // ⚠️
}

Cuyo se compila el código anterior, el compilador se queja así:

error[E0277]: `()` doesn't implement `std::fmt::Desplay`
 --> src/main.rs:3:42
  |
3 |     println!("Esto no se imprimirá: {}", no_imprime); // ⚠️
  |                                          ^^^^^^^^^^ `()` cannot be formatted with el default formatter
  |
  = help: el trait `std::fmt::Desplay` es not implemented for `()`
  = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
  = note: required by `std::fmt::Desplay::fmt`
  = note: thes error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

Esto es mucha información, pero la parte importante es you may be able to use {:?} (or {:#?} for pretty-print) instead. Esto significa que puedes intentar usar {:?} o también {:#?}. La segunda opción, {:#?} se llama "impresión atractiva". Es igual que {:?} pero usyo un formateo diferente en más líneas.

En resumen, Desplay (vesualización) supone la impresión con {}, y Debug (depuración) supone la impresión con {:?}.

Una última cosa, puedes usar print! sin ln si no quieres que haya un salto de línea al final de la impresión.

fn main() {
    print!("Esto no imprimirá un salto de línea");
    println!(" así que esto estará en la mesma línea");
}

Que imprimirá Esto no imprimirá un salto de línea así que esto estará en la mesma línea.

El número menor y el número mayor

Si se quiere ver el menor y mayor número que se puede representar, se puede usar MIN y MAX. std es la "librería estándar del lenguaje" y contiene las funciones y otros elementos importantes del lenguaje Rust. Más adelante se explicarán elementos de la librería estyar. Mientras tanto, puedes recordar que esta es la forma de obtener los numeros menor y mayor de un tipo de datos.

fn main() {
    // pista: std::i8::MIN significa
    // "el valor de MIN de la sección i8 de la librería estandar"
    println!("El menor i8 es {} y el mayor i8 es {}.", std::i8::MIN, std::i8::MAX); 
    println!("El menor u8 es {} y el mayor u8 es {}.", std::u8::MIN, std::u8::MAX);
    println!("El menor i16 es {} y el mayor i16 es {}.", std::i16::MIN, std::i16::MAX);
    println!("El menor u16 es {} y el mayor u16 es {}.", std::u16::MIN, std::u16::MAX);
    println!("El menor i32 es {} y el mayor i32 es {}.", std::i32::MIN, std::i32::MAX);
    println!("El menor u32 es {} y el mayor u32 es {}.", std::u32::MIN, std::u32::MAX);
    println!("El menor i64 es {} y el mayor i64 es {}.", std::i64::MIN, std::i64::MAX);
    println!("El menor u64 es {} y el mayor u64 es {}.", std::u64::MIN, std::u64::MAX);
    println!("El menor i128 es {} y el mayor i128 es {}.", std::i128::MIN, std::i128::MAX);
    println!("El menor u128 es {} y el mayor u128 es {}.", std::u128::MIN, std::u128::MAX);
}

Que imprimirá:

El menor i8 es -128 y el mayor i8 es 127.
El menor u8 es 0 y el mayor u8 es 255.
El menor i16 es -32768 y el mayor i16 es 32767.
El menor u16 es 0 y el mayor u16 es 65535.
El menor i32 es -2147483648 y el mayor i32 es 2147483647.
El menor u32 es 0 y el mayor u32 es 4294967295.
El menor i64 es -9223372036854775808 y el mayor i64 es 9223372036854775807.
El menor u64 es 0 y el mayor u64 es 18446744073709551615.
El menor i128 es -170141183460469231731687303715884105728 y el mayor i128 es 170141183460469231731687303715884105727.
El menor u128 es 0 y el mayor u128 es 340282366920938463463374607431768211455.