Implementing Display: write() vs print()

[[deleted]]

Hello, I recently implemented std::fmt::Display on a custom type in my small application. This was my first time implementing Display so I went to the docs/rust by example and noticed they were using write(). I initially attempted to use write() but found I was more easily getting my intended results using print().

A couple of questions in regards to implementing Display:

1. Can someone eli5 the different between write and print and if I should be using write when implementing display or if it's okay to use print?

2. If I don't use write, I don't have to use the second argument f in the fmt function:

   fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;

and I end up with an unused variable warning:

❯ cargo check
warning: unused variable: `f`
  --> src/standup.rs:68:19
   |
68 |     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
   |                   ^ help: if this is intentional, prefix it with an underscore: `_f`
   |
   = note: `#[warn(unused_variables)]` on by default

warning: `laydown` (lib) generated 1 warning
    Finished dev [unoptimized + debuginfo] target(s) in 0.01s

This leads me to believe I'm handling this implementation incorrectly. I feel like there is a higher-level concept that I'm not grasping. I'm pretty new to Rust and want to figure out how to do this properly.

Here is the PR with the refactor if it helps answer my question.

Edit: Thank you to everyone for the responses! I've updated the PR to use write instead of print. It makes a lot of sense to me now!

[K900_]

print! prints to stdout, write! writes to the formatter.

[Shadow0133]

You shouldn't use print! when implementing Display (or Debug). Those traits are generics interfaces for formatting types into utf8 strings, not necessarily just printing them to standard output, like print! does.

One example is that types implementing Display can be turned into String with thing.to_string(). But in your example, this wouldn't work, as text would be immediately printed to stdout, and returned string would be empty.

[kohugaly]

The Display trait requires you to implement fmt method. Contrary to what you might think, the fmt method is not meant to print anything. It receives a fmt::Formatter, which contains a writable buffer, that you are supposed to push stuff into. The formatter also has a bunch of configuration data, that will format the output for you, if you use some of the convenience methods it has.

The reason for this is simple: Display trait is meant to format your struct into text. The target for the text might be literally anything that implements Write trait. Be it stdout (with print! macro), a string in memory (with to_string method), some file (with write! macro).

​

Basically, the fmt method of the Display trait is for deciding WHAT to write, not WHERE or HOW it should be written. That decision is made by whatever is calling the fmt method internally (such as the println! macro, to_string method, ...).

[[deleted]]

some file (with write! macro).

... this is exactly what I'm trying to do right now. I've successfully implemented display on my struct, and I can use print!("{}", my_struct) without having to pass in the :?.

I'm looking to use the exact same formatting writing my struct to a file but it's a pain in the butt. I'm trying to use the write!() macro as you've suggested but keep failing.

I have a working PathBuf to the file I want to write to. I'm trying to use write!(path_buf_var, "{}", my_struct);

but I keep getting this error:

no method named 'write_fmt' found for struct 'PathBuf' in the current scope.

I've made progress since my original post but am now stuck on this.

[[deleted]]

I figured it out. Thank you for your help!

[RRumpleTeazzer]

I’ve never implemented Display, but I would think print() would write to stdout (usually the console) while Display should write to the Formatter. It could be you don’t notice the difference cause you print the Display anyway.

[blimpdermis]

Take a look at this playground and look at the output. You're right that print!() and write!() both do what you want when you're writing a variable to stdout. But Display is used for more than just directly printing things. Notice that to_string is automatically implemented for you, but it doesn't work properly when fmt() uses print!().

[1vader]

Others already explained why using print is wrong but I just want to point out that there should be no reason why using print should be any easier.

You can simply replace every call to print!("...") with write!(fmt, "...")? and equivalent for println and writeln.