Use without macros

[jbirnick]

Hey, let 's say I have a hashmap : HashMap<i8,u32>, and I want to serialize this as a sequence of tuples (i8,u32). How can I do that without creating an extra struct and using an attribute macro like serde_as?

I just want to do that sort of in-place on the hashmap variable, I don't want the hashmap to be contained in a "parent struct".

I think that would be possible if I could e.g. construct a Seq by myself, but I think I can't do that because the fields are private?

Any help is very much appreciated!

[jonasbb]

Yes, you can do it. You do not construct a Seq. Most of the types in this crate are meant to be constructed and carried around. Often they do not even have any data, but just behavior implemented.

use serde_with::*;
use std::collections::HashMap;

fn main() {
    let hashmap: HashMap<i8, u32> = HashMap::from([(1, 2), (3, 4)]);
    let mut data = Vec::new();
    {
        let mut ser = serde_json::Serializer::new(&mut data);
        As::<Seq<(Same, Same)>>::serialize(&hashmap, &mut ser).unwrap();
    }
    let json = String::from_utf8(data).unwrap();
    println!("{json}"); // prints [[1,2],[3,4]]
}

To get this part As::<Seq<(Same, Same)>> right you have to perform all the steps of the serde_as macro as documented https://docs.rs/serde_with/latest/serde_with/attr.serde_as.html#what-this-macro-does. The rest of the complexity is working with a Serializer instead of using the pre-made to_string. Not all data formats expose their Serializer and Deserializer though.

[jbirnick]

Okay thanks! And what if I want to serialize (value, key) tuples instead of (key, value) tuples?

I think there were similar questions around where people only wanted to serialize the keys. As far as I understand in such a case I have to write my own serializer?

[jonasbb]

If you want to switch the tuple order you need to create a new type, basically identical to the Seq used above, but changing the order. Serializing only the key or only the value would work similarly, probably a bit simpler than Seq.