Serialization Issue with Unit Types in SlotMap<ID, ()>

[maximsnoep]

First of all, thank you for maintaining the slotmap crate.

I'm currently using SlotMap with various generic types (VertData, FaceData, EdgeData) to manage graph data in my application:

SlotMap<VertID, VertData>
SlotMap<FaceID, FaceData>
SlotMap<EdgeID, EdgeData>

Occasionally, I use unit types for certain slot maps when no specific data needs to be stored (i.e., SlotMap<EdgeID, ()>). However, I've encountered serialization and deserialization issues when using unit types.

Issue

When attempting to serialize and deserialize a SlotMap<ID, ()>, it results in an error: "inconsistent occupation in Slot".

This seems to be triggered by the serialization behavior of the unit type (), which Serde serializes as "null" and then deserializes as None:

if occupied ^ serde_slot.value.is_some() {
    return Err(de::Error::custom("inconsistent occupation in Slot"));
}

Is this expected behavior?

[MeGaGiGaGon]

The issue isn't with slotmap, it's with whatever serde backend you are using (for me, serde_json). Assuming serde_json, the problem is it serializes unit (), ZSTs, and Option::None all to the value none. Then when deserializing, that makes serde_slot.value None instead of Some(()/ZST), triggering the error. From what I can see, this can't be fixed on slotmap's end, because of niche ZST weirdness. I have opened an issue about this in serde_json: serde-rs/json#1232

I did find a workaround, using this ZST type. There might be better/safer ways to implement it, but it works for me.
Edit: Since this is already cursed, might as well optimize by storing as 1 instead of "ZST".

struct ZST;

impl Serialize for ZST {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer {
        serializer.serialize_u8(1)
    }
}

impl<'de> Deserialize<'de> for ZST {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de> {
        deserializer.deserialize_u8(ZST)
    }
}

impl<'de> Visitor<'de> for ZST {
    type Value = ZST;

    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        formatter.write_str("the ZST named ZST")
    }
    // u64 instead of u8 because json makes everything u64 by default
    fn visit_u64<E>(self, _v: u64) -> Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        Ok(Self)
    }
}