Confusion how serde decimal support works

[pronebird]

Hi,

Today I wrote a struct with one field using #[serde(with = "rust_decimal::serde::str")] and the other not:

#[serde(Serialize, Deserialize)]
struct S {
  #[serde(with = "rust_decimal::serde::str")]
  pub field_a: Decimal,
  pub field_b: Decimal
}

Which surprise compiled. That begs the question what is going on with field a and b.

So I traced the execution and found that the field A is serialized with rust_decimal::serde::str::serialize:

pub fn serialize<S>(value: &Decimal, serializer: S) -> Result<S::Ok, S::Error>
where
    S: serde::Serializer,
{
    let value = crate::str::to_str_internal(value, true, None);
    serializer.serialize_str(value.0.as_ref())
}

The field B is serialized using the following imp:

#[cfg(not(feature = "serde-float"))]
impl serde::Serialize for Decimal {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        let value = crate::str::to_str_internal(self, true, None);
        serializer.serialize_str(value.0.as_ref())
    }
}

So in essence the implementation is the same but two different code paths. So which one should the casual user of rust_decimal rely upon?

I am using serde-with-str feature but frankly I don't remember how and when I plugged it in. I think that there was no default serialization for Decimal in the past, maybe it was added recently? Anyhow that feels confusing that there are two individual code paths exist that ultimately do the same thing. Documentation isn't very helpful neither.

It does however seem that deserialization works differently, i.e rust_decimal::serde::str only accepts strings, but without it JSON strings, integers and floats are parsed into Decimal.

[Tony-Samuels]

serde-*(e.g. serde-str) features allow you to override the default (de-)serialization strategy globally.
serde-with-* (e.g. `serde-with-str) features allow you to override the default (de-)serialization strategy on a case-by-case basis.

We would generally recommend using the serde-with-* features where possible.

As for which you want to use? That depends on how you want your types to be (de-)serialized.