want version of dbg! using {:?} not {:#?}

[ijackson]

I find the pretty-printing output from dbg! more annoying than helpful and I am privately using a version of this macro that doesn't pretty-print.

When I discussed this on the Discord several people also shared the same opinion about dbg!'s pretty-printing. (No-one really said they liked it, although that's a biased sample...) This suggests that there would be demand for a compact output version in std. While the docs for std::dbg! say the output format cannot be relied on, ISTM that changing it to remove the # would be rude (and controversial). So I suggest providing a compact version in parallel. I suggest the name dbgc! for "debug compact" but I am of course happy with whatever colour bikeshed.

If the libs team thinks this would be welcome, I will make an MR for it. If the libs team don't like this idea then fine, I can keep using my clone-and-hack :-).

While I'm here I notice that the docs suggest committing calls to dbg! is a bad idea. grepping my own codebase showed that I agree with one significant exception: I use it liberally in tests. I think it's great there and the docs could probably mention that as a good use case.

[ijackson]

@rustbot modify labels +C-feature-request +T-libs

[cuviper]

Another bikeshed possibility is to have an alternate pattern added to dbg!, perhaps using a (non-expression) sigil prefix. There's no obvious choice to me unless we flip it -- e.g. make dbg!(foo) plain and let dbg!(# foo) be pretty, but even that probably conflicts with expression attributes.

[ChrisJefferson]

If someone wanted to try this out as a package first, I'd personally use it.

[joshtriplett]

@ijackson wrote:

(No-one really said they liked it, although that's a biased sample...)

It tends to depend on the nature of the output you have. When printing a complex structure, especially a nested structure, the # output can be wildly useful. When printing an array of bytes, on the other hand, I rarely want the bytes listed one-per-line. (Though that can sometimes be a sign that a BString/BStr would help, as well.)

It might be worth considering improvements to the {:#?} formatting, for specific cases where it produces suboptimal results. As one potential example, we could potentially use specialization to provide better Debug output for Vec<u8>.

All that said, we have both formats for a reason, and it's not unreasonable to want access to both. The question then becomes, how often do people want a dbg! with the non-# output, and is that worth an abbreviated name?

It's also worth noting that we could provide a macro with a less-abbreviated name, and people who want a more abbreviated version could use std::debug_compact as dbgc (for instance). So there are two questions here: should we provide this macro, and should we provide it under an abbreviated name?

@cuviper I personally don't think it'd be a good idea to add a semi-magic argument to the `dbg! macro to change the output format.

While I'm here I notice that the docs suggest committing calls to dbg! is a bad idea. grepping my own codebase showed that I agree with one significant exception: I use it liberally in tests. I think it's great there and the docs could probably mention that as a good use case.

This seems reasonable, and I'd be happy to r+ a PR adding such a note to the documentation.

[Milo123459]

Another bikeshed possibility is to have an alternate pattern added to dbg!, perhaps using a (non-expression) sigil prefix. There's no obvious choice to me unless we flip it -- e.g. make dbg!(foo) plain and let dbg!(# foo) be pretty, but even that probably conflicts with expression attributes.

I'm looking to implement this, and I personally think dbg!(# foo) should be the un-prettyprinted version.

Also - am I good to claim?

[Dylan-DPC]

Closing this as it is better suited to be trialed as a crate (there are a few present already now but weren't around at the time this issue was created).