Display

Изходът от fmt::Debug рядко изглежда сбит и чист. Често е по-добре сами да нагодим начина на показване. Това се постига като сами осъществим отличителя fmt::Display. Той използва означението {} при извеждане на низ на екрана. Осъществяването изглежда така:

#![allow(unused)]
fn main() {
// Внасяме модула `fmt`, за да можем да го ползваме (`use`).
use std::fmt;

// Описваме структура, за която ще осъществим `fmt::Display`
// Това е разнородна поредица, именувана `Structure`,
// която съдържа един член от тип `i32`.
struct Structure(i32);

// За да използваме означението `{}`, трябва ръчно да осъществим `impl fmt::Display`
// за типa `for Structure`.
impl fmt::Display for Structure {
    // Този отличител изисква да се осъществи метода `fmt` с точно това описание⁴.
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // Пишем първия член в подадения изходен поток `f`.
        // write! връща данни от тип `fmt::Result`,
        // който показва дали действието (писане) е успяло или не.
        // Обърнете внимание, че правописът⁵  на `write!`
        // е много подобен на `println!`.
        write!(f, "{}", self.0)
    }
}
}

fmt::Display може да е по-изчистен от fmt::Debug, но се появяват някои затруднения за библиотеката std. Как би трябвало да се показват неопределени типове? Например ако std осъществеше един единствен начин за показване за всички Vec<T>, какъв щеше да е той? Би ли бил някой от тези двата?

  • Vec<path>: /:/etc:/home/username:/bin (разделяме с :)
  • Vec<number>: 1,2,3 (разделяме със ,)

Не, защото няма съвършен начин за показване на всички типове и библиотеката std не налага никакъв. fmt::Display не е осъществен за Vec<T> и за никакви обобщени съдържащи типове1. В тези случаи (показване на обобщени съдържащи типове) се налага да ползваме fmt::Debug.

Това не е пречка все пак, защото за всеки съдържащ тип, който не е обобщен, можем да осъществим fmt::Display.

use std::fmt; // Внасяме `fmt`.

// Структура, съдържаща две числа. Ще я направим производна на `Debug`,
// за да сравним изгледа с осъществения от нас `Display`.
#[derive(Debug)]
struct MinMax(i64, i64);

// Осъществяваме `Display` за `MinMax`.
impl fmt::Display for MinMax {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // Използваме `self.пореден_номер`, за да достъпим всяко парче данни.
        write!(f, "({}, {})", self.0, self.1)
    }
}

// Описваме структура с именувани полета, за да я сравним.
#[derive(Debug)]
struct Point2D {
    x: f64,
    y: f64,
}

// По подобен начин осъществяваме `Display` за `Point2D`.
impl fmt::Display for Point2D {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // Показваме само `x` и `y`.
        write!(f, "x: {}, y: {}", self.x, self.y)
    }
}

fn main() {
    let minmax = MinMax(0, 14);

    println!("Сравняваме показването на структури:");
    println!("Display: {}", minmax);
    println!("Debug: {:?}", minmax);

    let big_range =   MinMax(-300, 300);
    let small_range = MinMax(-3, 3);

    println!("Големият порядък е {big}, а малкият е {small}",
             small = small_range,
             big = big_range);

    let point = Point2D { x: 3.3, y: 7.2 };

    println!("Сравняваме показването на точки:");
    println!("Display: {}", point);
    println!("Debug: {:?}", point);

    // Грешка. `Debug` и `Display` са осъществени, но `{:b}`
    // изисква осъществяване на `fmt::Binary`. Следното няма да работи.
    // println!("Как изглежда Point2D, представен двоично: {:b}?", point);
}

Осъществихме fmt::Display, но не и fmt::Binary, и затова не можем да го ползваме. std::fmtпредоставя много такива отличители и всеки трябва да бъде осъществен поотделно. Това е описано подробно в std::fmt.

Упражнение

След като проверите изхода от горния пример, използвайте структурата Point2D като ръководство, за да добавите нова структура – Complex към примера. При отпечатване изходът трябва да изглежда така:

Display: 3.3 + 7.2i
Debug: Complex { real: 3.3, imag: 7.2 }

Б. пр.

1

обобщени съдържащи типове – generic containers

2

разнородна поредица – tuple, вижте разнородни поредици

3

член – element

4

описание (на функция/метод) – signature

5

правопис – syntax

Вижте също:

Производни, std::fmt, macro_rules!, Структури, Отличители и Обявлението use