Merge traits and use an alternate flag

[muturgan]

a Formatter instanse has an alternate flag which is true when a logging call has a # symbol in braces. you can use it to check is pretty necessary

[jofas]

I'm not sure I'm following. Are you proposing something like

#[derive(Serialize, DisplayAsJson)]
#[display_as_json(pretty)]
struct Foo {
    bar: String,
    baz: i32,
    bat: bool,
}

let f = Foo { bar: "bar".to_owned(), baz: 0, bat: true };

let result = r#"{
  "bar": "bar",
  "baz": 0,
  "bat": true
}"#;

let f_ser = format!("{}", f);

assert_eq!(f_ser, result);

instead of

#[derive(Serialize, DisplayAsJsonPretty)]
struct Foo {
    bar: String,
    baz: i32,
    bat: bool,
}

let f = Foo { bar: "bar".to_owned(), baz: 0, bat: true };

let result = r#"{
  "bar": "bar",
  "baz": 0,
  "bat": true
}"#;

let f_ser = format!("{}", f);

assert_eq!(f_ser, result);

for using the pretty formatter instead of the default compact formatter?

[muturgan]

when you formatting something, you can tune it with passing additional symbols-options. one of it - a "#" symbol. it is a rust native way to say "print it pretty please". compare this:

let v = vec![Some(5), None];
println!("{:?}", v);
println!("{:#?}", v)

inside of an fmt method you can check this option via an alternate method of a Formatter

impl Display for MyStruct {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        let inner = if f.alternate() {
            // with #
            serde_json::to_string_pretty(self)
        } else {
            serde_json::to_string(self)
        }
        .map_err(|_| fmt::Error)?;

        write!(f, "MyStruct {inner}")
    }
}

so I suggest you to implement only a DisplayAsJson trait which will able to print things both ways. let developers switch it's behavior with #

[jofas]

I see, thanks for the clarification. I'd like to add support for alternate formatting. This is indeed a good enhancement to the API.

Based on this discussion though, I am starting to wonder if we maybe want to provide an (advanced) API for people to specify their formatters themselves, allowing them to override the default printing behaviour (compact for normal, pretty for the alternate formatter, as per your suggestion). Something like I envisioned earlier with attributes:

#[derive(Serialize, DisplayAsJson)]
#[display_as_json(formatter = "compact")] // allows using custom formatters as well 
#[display_as_json(alternate = "pretty")]
struct Foo {
    bar: String,
    baz: i32,
    bat: bool,
}

let f = Foo { bar: "bar".to_owned(), baz: 0, bat: true };

let result_compact = r#"{"bar": "bar", "baz": 0, "bat": true}"#;

let result_pretty = r#"{
  "bar": "bar",
  "baz": 0,
  "bat": true
}"#;

assert_eq!(format!("{f}"), result_compact);
assert_eq!(format!("{f:#}"), result_pretty);

This would make the API even more flexible, plus the nicer default behaviour you suggested.