Serde Tips

Tooling

• There’s a automated tool which creates structs based on JSON, transform.tools

Untagged enums

Untagged unions are extremely slow to parse compared to tagged unions. If you care about performance, it’s always better to have a property you can discriminate union variants by.

• This is because there’s no explicit information about which variant each data represents. The parser must try to deserialize the data into each variant until it finds a match.
• If you do use untagged union, the order of the enum variants matters. Always put the most commons first, it will speed up the process.
• ⚠️ Besides performance, this also has semantic implications: if a given input fits more than one variant (that is, its deserialization is ambiguous), then the first fitting variant will be chosen. If your enum derives both Deserialize and Serialize, then it may not round-trip correctly.
• There’s a crate serde_untagged which helps use untagged enums.

Discarding/Ignoring Data

• You don’t need to specify fields you’re not using. Serde will just ignore members which are absent from the target.
• IgnoredAny: Documentation
• There’s a type serde_json::Number that avoids converting to number formats until you actually want to spend the processing time
• There’s also the serde_json::value::RawValue

Others

• You can avoid allocations of Strings by parsing to a data structure that uses &str fields

• Adding #[serde(borrow)] could increase performance a lot.

  • When using Cow(like Cow<str>, it will always parse to Cow::Owned unless you specify #[serde(borrow)].
  • Documentation

• If you’re using a tagged union to discriminate based on a JSON property value, you don’t have to use the name of your enum variant, you can use aliases.

  #[serde(tag="animal_type")]
  enum Animal {
     #[serde(alias="crab")]
     Crab(MyCrabStruct),
     #[serde(alias="gopher")]
     Gopher(MyGopherStruct)
  }
  

  • However, beware that alias and renmae is different.
    • If you want to just give something a different name, use rename instead of alias. alias gives it an alternative name that the parser will also accept, but the unaliased name remains the canonical one that will appear in serialization output.

Pitfalls

• A struct can also be a list

  // This can either be `{"x": 1, "y": 2}` or `[1, 2]`
  // They're both valid representations
  #[derive(Deserialize)]
  struct Point {
      x: u32,
      y: u32,
  }
  

References

• Things I wish I had known about serde_json