SafeCopy extends the parsing and serialization capabilities of Data.Binary
to include nested version control. Nested version control means that you
can change the defintion and binary format of a type nested deep within
other types without problems.

Consider this scenario. You want to store your contact list on disk
and so write the following code:

At this point, everything is fine. You get the awesome speed of Data.Binary
together with Haskell's easy of use. However, things quickly takes a turn for the worse
when you realize that you want to keep phone numbers as well as names and
addresses. Being the experienced coder that you are, you see that using a 3-tuple
isn't very pretty and you'd rather use a record. At first you fear that this
change in structure will invalidate all your old data. Those fears are quickly quelled,
though, when you remember how nifty SafeCopy is. With renewed enthusiasm,
you set out and write the following code:

The extension kind lets the system know that there is
at least one previous version of this type. A given data type
can only extend a single other data type. However, it is
perfectly fine to build chains of extensions. The migrations
between each step is handled automatically.

To ensure that no-one reads or writes values without handling versions
correct, it is necessary to restrict access to getCopy and putCopy.
This is where Contained enters the picture. It allows you to put
values in to a container but not to take them out again.