It looks like you fell into the same trap that I fell into when I moved from C++ to Rust. Trying to use polymorphism to model a fixed set of variants of a type. Rust’s enums (similar to Haskell’s enums, and equivalent to Ada’s variant record types) are different from classical enums in other languages, … Read more
Serde supports an interesting selection of attributes that can be used to customize the serialization or deserialization for a type while still using the derived implementation for the most part. In your case, you need to be able to decode a field that can be specified as one of multiple types, and you don’t need … Read more
Add an attribute to the field: #[serde(borrow)]. That will indicate to serde that it should be borrowing the value. You must provide this attribute for every borrow except for &str and &[u8]. Source: https://serde.rs/lifetimes.html#borrowing-data-in-a-derived-impl
The default behaviour of struct deserialization is to assign fields with their respective default value when they are not present in their serialized form. Note that this is different from the container #[serde(default)] attribute, which fills in the fields with the struct’s default value. #[derive(Debug, PartialEq, Deserialize)] pub struct Foo<‘a> { x: Option<&’a str>, } … Read more
You can use the untagged attribute which will produce the desired output. You won’t need to implement Serialize yourself with this: #[derive(Debug, Serialize)] #[serde(untagged)] enum TValue<‘a> { String(&’a str), Int(&’a i32), } If you wanted to implement Serialize yourself, I believe you want to skip your variant so you should not use serialize_newtype_variant() as it … Read more
I found an answer from Serde issue 891: I should use DeserializeOwned instead of Deserialize.
For serializing Serde trait objects you should use erased-serde. #[macro_use] extern crate serde_derive; #[macro_use] extern crate erased_serde; extern crate serde; extern crate serde_json; #[derive(Serialize)] struct Card { sections: Vec<Section>, } #[derive(Serialize)] struct Section { header: String, widgets: Vec<Box<dyn WidgetTrait>>, } #[derive(Serialize)] struct Image { image_url: String, } #[derive(Serialize)] struct KeyValue { top_label: String, content: String, … Read more
Building off of E_net4’s answer, you can also create an enum for the three possibilities: #[derive(Debug)] enum Patch<T> { Missing, Null, Value(T), } impl<T> Default for Patch<T> { fn default() -> Self { Patch::Missing } } impl<T> From<Option<T>> for Patch<T> { fn from(opt: Option<T>) -> Patch<T> { match opt { Some(v) => Patch::Value(v), None => … Read more
Here’s one way of doing that: #[macro_use] extern crate serde_derive; // 1.0.117 extern crate serde; // 1.0.117 extern crate serde_json; // 1.0.59 #[derive(Serialize, Deserialize, Debug)] pub struct MyError { error: String, } #[derive(Serialize, Deserialize, Debug)] pub struct MyAge { age: i32, name: String, } #[derive(Debug)] enum AgeOrError { Age(MyAge), Error(MyError), } impl serde::Serialize for AgeOrError … Read more
This has been implemented by dtolnay. The concept is quite clever ans is explained in the README: How does it work? We use the inventory crate to produce a registry of impls of your trait, which is built on the ctor crate to hook up initialization functions that insert into the registry. The first Box<dyn … Read more