Safe implementation from a single spec

[mgsloan]

Continuing along the line of thought for making store safer for some uses (#36), it also makes sense to consider a mechanism for implementing custom serialization safely.

Currently, you really have to be careful that your peek / poke / size methods are implemented consistently. peek and poke need to agree upon the serialization format. You can even cause seg faults if your size function is wrong! In practice, this isn't a big deal due to a combination of generics / TH and testing.

It feels a bit un-haskell-ey to do things in such an unsafe way. How can we make it safer? I think it's possible!

JsonGrammar

Take, for example, the JsonGrammar project: https://github.com/MedeaMelana/JsonGrammar2

It leverages some fancy lensy constructions to allow you to specify json encoding and decoding with a single method definition. Thankfully, I think this variety of binary serialization can be done without quite as much fanciness. This is because we can expect a particular order of input, whereas JsonGrammar needs to allow you descend into particular fields by name.

Sum types are still quite tricky, though. JsonGrammar uses "stack prisms" to handle this. That may well be the most viable approach. However, I have a suspicion that something like dependent-sum could be sufficient to get a solution that isn't too hairy, and allows us to use case statements. Since I haven't quite figured out this bit, omitting the speculative code I have for it.

Rough sketch

For product types, I'm imagining something roughly like:

-- A serialization which can be used to implement size / peek / poke
data Serialize a
serializeSize :: Serialize a -> Size a
serializePeek :: Serialize a -> Peek a
serializePoke :: Serialize a -> a -> Poke ()

-- Applicative serialization has a hope of being 'ConstSize'
data SerializeA a
instance Applicative SerializeA
mkSerializeA :: (a -> SerializeA a) -> Serialize a
serializeA :: Store a => SerializeA a

-- Monadic serialization is always 'VarSize'
data SerializeM a
instance Monad SerializeM
mkSerializeM :: (a -> SerializeM a) -> Serialize a
serializeM :: Store a => SerializeM a

-- Example use

serializeTuple :: (Store a, Store b) => Serialize (a, b)
serializeTuple = mkSerializeA $ \(a, b) -> (,) <$> serializeA a <*> serializeA b

instance Store (a, b) where
    size = serializeSize serializeTuple
    peek = serializePeek serializeTuple
    poke = serializePoke serializeTuple

Together with Instantiators provided by th-utilities, we could have quite concise declaration of Store instances. Instead of the -- Example use above, we could just write:

$($(derive [d|
    instance StoreSafe X where
        storeSafe = mkSerializeA $ \Prod a b -> Prod <$> serialize a <*> serialize b
    |]))