Rust by Example - страница 3
>// Derive the `fmt::Debug` implementation for `Structure`. `Structure`
>// is a structure which contains a single `i32`.
>#[derive(Debug)]
>struct Structure(i32);
>// Put a `Structure` inside of the structure `Deep`. Make it printable
>// also.
>#[derive(Debug)]
>struct Deep(Structure);
>fn main() {
>// Printing with `{:?}` is similar to with `{}`.
>println!("{:?} months in a year.", 12);
>println!("{1:?} {0:?} is the {actor:?} name.",
>"Slater",
>"Christian",
>actor="actor's");
>// `Structure` is printable!
>println!("Now {:?} will print!", Structure(3));
>// The problem with `derive` is there is no control over how
>// the results look. What if I want this to just show a `7`?
>println!("Now {:?} will print!", Deep(Structure(7)));
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
So fmt::Debug definitely makes this printable but sacrifices some elegance. Rust also provides "pretty printing" with {:#?}.
>#[derive(Debug)]
>struct Person<'a> {
>name: &'a str,
>age: u8
>}
>fn main() {
>let name = "Peter";
>let age = 27;
>let peter = Person { name, age };
>// Pretty print
>println!("{:#?}", peter);
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
One can manually implement fmt::Display to control the display.
attributes, derive, std::fmt, and struct
fmt::Debug hardly looks compact and clean, so it is often advantageous to customize the output appearance. This is done by manually implementing fmt::Display, which uses the {} print marker. Implementing it looks like this:
>#![allow(unused)]
>fn main() {
>// Import (via `use`) the `fmt` module to make it available.
>use std::fmt;
>// Define a structure for which `fmt::Display` will be implemented. This is
>// a tuple struct named `Structure` that contains an `i32`.
>struct Structure(i32);
>// To use the `{}` marker, the trait `fmt::Display` must be implemented
>// manually for the type.
>impl fmt::Display for Structure {
>// This trait requires `fmt` with this exact signature.
>fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
>// Write strictly the first element into the supplied output
>// stream: `f`. Returns `fmt::Result` which indicates whether the
>// operation succeeded or failed. Note that `write!` uses syntax which
>// is very similar to `println!`.
>write!(f, "{}", self.0)
>}
>}
>}
fmt::Display may be cleaner than fmt::Debug but this presents a problem for the std library. How should ambiguous types be displayed? For example, if the std library implemented a single style for all Vec
• Vec
• Vec
No, because there is no ideal style for all types and the std library doesn't presume to dictate one. fmt::Display is not implemented for Vec
This is not a problem though because for any new container type which is not generic,fmt::Display can be implemented.
>use std::fmt; // Import `fmt`
>// A structure holding two numbers. `Debug` will be derived so the results can
>// be contrasted with `Display`.
>#[derive(Debug)]
>struct MinMax(i64, i64);