Tipos Imprimibles en la Biblioteca Estándar de Rust

Introducción

En este laboratorio, se explica que para utilizar las características de formato std::fmt, los tipos deben tener una implementación para ser imprimibles, lo cual puede ser proporcionado automáticamente para los tipos en la biblioteca std. Para otros tipos, se puede derivar la característica fmt::Debug para habilitar la impresión. La característica fmt::Debug hace que sea sencillo implementar tipos imprimibles, mientras que fmt::Display debe ser implementado manualmente. La característica fmt::Debug permite que todos los tipos deriven la implementación para la impresión, y lo mismo aplica a {:?} para los tipos de la biblioteca std. El laboratorio también menciona el uso de {:?} para la impresión y proporciona un ejemplo de cómo usarlo para imprimir diferentes tipos. Además, se introduce el concepto de "impresión bonita" con {:#?}, que proporciona una representación más elegante de las estructuras de datos. Finalmente, se menciona que fmt::Display se puede implementar manualmente para tener control sobre la representación de los tipos.

Nota: Si el laboratorio no especifica un nombre de archivo, puede utilizar cualquier nombre de archivo que desee. Por ejemplo, puede utilizar main.rs, compilar y ejecutarlo con rustc main.rs &&./main.

Depuración

Todos los tipos que deseen utilizar las características de formato std::fmt requieren una implementación para ser imprimibles. Las implementaciones automáticas solo se proporcionan para tipos como los de la biblioteca std. Todos los demás deben ser implementados manualmente de alguna manera.

La característica fmt::Debug hace esto muy sencillo. Todos los tipos pueden derivar (crear automáticamente) la implementación de fmt::Debug. Esto no es cierto para fmt::Display, que debe ser implementado manualmente.

// Esta estructura no se puede imprimir con `fmt::Display` ni
// con `fmt::Debug`.
struct UnPrintable(i32);

// El atributo `derive` crea automáticamente la implementación
// necesaria para hacer que esta `struct` sea imprimible con `fmt::Debug`.
#[derive(Debug)]
struct DebugPrintable(i32);

Todos los tipos de la biblioteca std también son automáticamente imprimibles con {:?}:

// Derive la implementación de `fmt::Debug` para `Structure`. `Structure`
// es una estructura que contiene un solo `i32`.
#[derive(Debug)]
struct Structure(i32);

// Coloca una `Structure` dentro de la estructura `Deep`. Haz que sea imprimible
// también.
#[derive(Debug)]
struct Deep(Structure);

fn main() {
    // Imprimir con `{:?}` es similar a con `{}`.
    println!("{:?} meses en un año.", 12);
    println!("{1:?} {0:?} es el {actor:?} nombre.",
             "Slater",
             "Christian",
             actor="actor's");

    // `Structure` es imprimible!
    println!("Ahora {:?} se imprimirá!", Structure(3));

    // El problema con `derive` es que no hay control sobre cómo
    // se ven los resultados. ¿Qué pasa si quiero que esto solo muestre un `7`?
    println!("Ahora {:?} se imprimirá!", Deep(Structure(7)));
}

Entonces fmt::Debug definitivamente hace que esto sea imprimible pero sacrifica algo de elegancia. Rust también proporciona "impresión bonita" con {:#?}.

#[derive(Debug)]
struct Person<'a> {
    name: &'a str,
    age: u8
}

fn main() {
    let name = "Peter";
    let age = 27;
    let peter = Person { name, age };

    // Impresión bonita
    println!("{:#?}", peter);
}

Uno puede implementar manualmente fmt::Display para controlar la representación.

Resumen

¡Felicitaciones! Has completado el laboratorio de Depuración. Puedes practicar más laboratorios en LabEx para mejorar tus habilidades.