Converting things to and from binary

[George Russell]

Sorry, I know there was an ongoing discussion on this topic somewhere, but I
can't find it, so I'll have to hope this list is the most appropriate.

The general problem to solve is "How to we convert things to and from a
binary format, so they can be efficiently written to and from disk".  I have
solved this (incompletely) twice myself, I expect Glasgow Haskell has solved
it too, there really ought to be a standard solution.

 From the deficiencies of my incomplete solutions I conclude:
(1) you don't want to force everything to go via single Haskell
characters.  This is horrendously inefficient when what you want is
to blast in and out large quantities of binary data, and of course
that's precisely where you probably want efficiency.
(2) you don't want a binary converter only to be able to write to
Handles.  I've found myself that it's useful to be able to
convert to (for example) vectors of bytes.

Now my idea is that this be implemented using monads.  For example,
consider the problem of writing out data to be converted into
binary.  We might consider there to be two primitive operations,
based on the types Byte (a single Byte) and Bytes (an array of bytes).
(I'm not sure exactly what these types should actually be in GHC.)

The consumer of binary data should provide a record like

data WriteBinaryData m = WriteBinaryData {
    writeByte :: Byte -> m (),
    writeBytes :: Bytes -> m ()
    }

Then something which can be written out in a binary form would instance
the class

class HasBinaryWrite a where
    writeA :: Monad m => WriteBinaryData m -> a -> m ()

The advantage of this approach is that an instance of HasBinary can both
be written to a file (m = IO) and to a byte vector.  Also this should
be fairly efficient I think, and it should be easy to build up more
complex instances of binary.

The converse functions would likewise use monads

data ReadBinaryData m = ReadBinaryData {
    readByte :: m Byte,
    readBytes :: Int -> m Bytes
    }

class HasBinaryRead a where
    readA :: Monad m => ReadBinaryData m -> m a

and again we can instance this either for files or for byte vectors, and
again building up more complex instances should be easy enough.

I wonder if this is the best way of doing this kind of thing, and if
so should it be implemented and put in the standard libraries?
Also, what should Byte and Bytes actually be?