Skip if default?

[leebenson]

Thanks for the useful lib!

I have a simple use-case, where I'd like to skip serialising a field if the contents of the field match its default.

I know I could write a macro to support this, but this seems like a fairly common use-case that it might be worth adding as an option similar to skip_serializing_none?

[jonasbb]

Hi, thanks for the idea. Maybe this other issue would also be able to solve your problem #85.

serde has two ways to use #[serde(default)]. You can place it either on a struct, in which case each field is filled with the default value from the struct, or you place it in the field, then the default of the field type is used.
Since you mention skip_serializing_none I assume you want to compare each field of the struct with the struct's default value.

How are you checking for "defaultness"? There might be some fields where the type doesn't implement Default.

I think I saw some discussions a while ago what exactly Default::default() == Default::default() is supposed to do. IIRC nothing guarantees that this evaluates to true.

[leebenson]

Thanks for linking to #85. I don't think that directly answers the use case of default fields, but it definitely helps with another issue I had, which was checking for emptiness on nested IndexMaps. Very useful, thanks!

Regarding default...

My hope for a #[skip_serializing_default] would be that:

1. When a field has a #[serde(default)], it's compared with $TYPE::Default()
2. When a field has a #[serde(default = "some_func")], a $VALUE == &some_func() is compared.
3. If #[serde(default)] is attached to the struct, each field must implement Default... so presume the first step, unless a specific default override is provided.

I haven't given much thought to the feasibility of this approach, or cases where Default != Default (which would always be true, for my particular field types)... but it seems to me (at least on the surface) that skip_serializing_none is very close to this behaviour except to compare against Default or a invoke a func that returns a value for comparison.

Does that seem reasonable? Or is my thinking off?

[leebenson]

(Re: #85... with the issue still being open, I presume that hasn't been implemented yet, correct? Just checking I'm not missing anything - thanks!)

[jonasbb]

#85 is still open, but I think it would be a useful macro to have.

But #85 will not help here. If #[skip_serializing_default] should parse #[serde(default = "some_func")] it requires special handling.
Implementation wise, this might need an opt-out, since a type might not be PartialEq.
It also requires a stable path for the is_default function. This means the crate name should be configureable too.

3. If #[serde(default)] is attached to the struct, each field must implement Default.

The struct must impl Default, not the fields. Although I think this is probably not too important. default on structs seems to be relatively unknown, such that it could be left as future work until there is demand for it.