Struct serde_with::Seq

pub struct Seq<V>(_);

De/Serialize a Map into a list of tuples

Some formats, like JSON, have limitations on the types of keys for maps. In case of JSON, keys are restricted to strings. Rust features more powerful keys, for example tuples, which can not be serialized to JSON.

This helper serializes the Map into a list of tuples, which do not have the same type restrictions.

Examples

#[serde_as]
#[derive(Deserialize, Serialize)]
struct A {
    #[serde_as(as = "Seq<(_, _)>")]
    s: BTreeMap<(String, u32), u32>,
}

// This converts the Rust type
let data = A {
    s: BTreeMap::from([
        (("Hello".to_string(), 123), 0),
        (("World".to_string(), 456), 1),
    ]),
};

// into this JSON
let value = json!({
    "s": [
        [["Hello", 123], 0],
        [["World", 456], 1]
    ]
});

assert_eq!(value, serde_json::to_value(&data).unwrap());
assert_eq!(data, serde_json::from_value(value).unwrap());

Trait Implementations

impl<'de, K, KAs, V, VAs> DeserializeAs<'de, BTreeMap<K, V, Global>> for Seq<(KAs, VAs)>where
    KAs: DeserializeAs<'de, K>,
    VAs: DeserializeAs<'de, V>,
    K: Ord,

fn deserialize_as<D>(deserializer: D) -> Result<BTreeMap<K, V>, D::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, K, KAs, V, VAs> DeserializeAs<'de, HashMap<K, V, RandomState>> for Seq<(KAs, VAs)>where
    KAs: DeserializeAs<'de, K>,
    VAs: DeserializeAs<'de, V>,
    K: Eq + Hash,

fn deserialize_as<D>(deserializer: D) -> Result<HashMap<K, V>, D::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, KAs, V, VAs> SerializeAs<BTreeMap<K, V, Global>> for Seq<(KAs, VAs)>where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>,

fn serialize_as<S>(
    source: &BTreeMap<K, V>,
    serializer: S
) -> Result<S::Ok, S::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, KAs, V, VAs> SerializeAs<HashMap<K, V, RandomState>> for Seq<(KAs, VAs)>where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>,

fn serialize_as<S>(
    source: &HashMap<K, V>,
    serializer: S
) -> Result<S::Ok, S::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.