Thread by @loige

I have been confused for a while on what's the best way to implement a "to string" functionality for a #Rust struct. 🦀

The reason why this has been confusing to me is that there are indeed many ways to do that and they all have different purposes!

This is what I learned

👇🧵

The first thing that you can do is to just implement a simple `to_string()` function directly on your struct!

play.rust-lang.org/?version=stabl…

This is easy and it works! But the implementation is very specific to our struct.

The rest of the codebase doesn't really know that this type can be converted to a String and therefore you cannot build abstractions on top of this... 🤨

In fact, note how we needed to explicitly call `to_string()` in our `println!()` call.

If we try to remove that and pass the `creds` instance we get an error:

"`Credentials` cannot be formatted with the default formatter" 🤷‍♀️

Wouldn't it be nice if we could make this work? 🤔

The error itself is quite insightful. It is saying that we can make this work if we implement a specific trait for our `Credentials` struct.

In Rust, exposing certain behaviors is done by implementing specific traits. Regarding "to string" there are, in fact, a few options!

3 options (that I know about) are:

1. the std::fmt::Debug Trait
2. the std::string::ToString Trait
3. the std::fmt::Display Trait (the one recommended by our error)

Let's start with the Debug trait. The documentation says "Debug should format the output in a programmer-facing, debugging context".

This is a great way to provide details about a struct that should be visible only to developers.

play.rust-lang.org/?version=stabl…

You can generally get Rust to auto-implement the trait for you by using the Derive macro:

`#[derive(Debug)]`

Then you can print an object in debug mode by using the placeholder `{:?}` in a format string.

🤫 Small productivity tip:

You can also use the `{:#?}` placeholder (note the hash) if you want the output to be pretty-printed! 🤯

But what if we want to customize the result of Debug?

For instance, we might not want to display the full secret string but only the first 4 chars.

Well, in this case, we can implement the Debug trait manually:

play.rust-lang.org/?version=stabl…

Implementing the Debug trait manually is something that you rarely have to do manually. For the majority of use cases, the Derive macro will serve you well!

It is interesting to note that implementing the Debug trait manually requires you to use a `Formatter`. 🤔

From the docs: "A Formatter represents various options related to formatting. Users do not construct Formatters directly; a mutable reference to one is passed to the fmt method of all formatting traits, like Debug and Display."

More info here: doc.rust-lang.org/std/fmt/struct…

Let's now talk about the std::string::ToString trait, which is defined as:

"A trait for converting a value to a String"

But the documentation also says it shouldn’t be implemented directly. `Display` should be implemented instead & you get the ToString implementation for free!

Implementing ToString for a struct will force you to have a `to_string()` method, but the common way to tell that an object can be converted to a string is the more generic `Display` trait. We can practically ignore the `ToString` trait at this point and focus only on Display!

"Display is similar to Debug, but Display is for user-facing output, and so cannot be derived".

The documentation is essentially saying that Display allows us to provide a user-facing description of a struct and that we can only implement the trait directly, no magic derive! 😓

Let's implement Display for our Credentials struct then...

play.rust-lang.org/?version=stabl…

Note that, again, we have to deal with a formatter.

A small productivity tip is that you can use the `write!` macro with formatters and convert:

```
f.write_str(self.api_key.as_ref())
```

to

```
write!(f, "{}", self.api_key)
```

Nicer (and more flexible), isn't it? 😜

Also, remember that the placeholder to use the Display trait is just `{}` (as opposed to `{:?}` or `{:#?}` for the Debug trait).

📃 So, just to summarise:

- `Debug` allows you to generate debug strings. It can be automatically derived.
- `Display` is the equivalent but for user-facing information. It CANNOT be derived.
- `ToString`... don't implement it, you get it for free with `Display`!

😎

That's all I know about stringifying things in Rust! 😊

I hope this was interesting and I am curious to know if you learned something new or if all these things were already done and dusted in your Rust journey!

Did I miss or misunderstood something? plz, let me know! ❤️

If you'd like to see more of my #Rust #learning journey check out my #twitch channel, where I stream every week (Monday 5PM GMT) with @gbinside and @88_eugen our attempts at cracking the #AdventOfCode challenges using Rust!

twitch.tv/loige

And if you prefer to read rather than watching long random-ish streaming sessions, you could check out out some of my recent Rust articles on my blog:

loige.co/tag/rust

CIAO 👋

All of this turned in a blog post: loige.co/how-to-to-stri…