Generate the following for the given type

• A 'case' function (see genCase)
• An instance of Packable (see genPackableInstance)
• An instance of Unpackable (see genUnpackableInstance)
• An instance of Skippable (see genSkippableInstance)

Example:

 $(mkPacked ''Tree [InsertFieldSize])

Options for the generation process.

Beware: these options alter the signature and behaviour of the generated functions.

Generates a function to allow pattern matching a packed data type using the data constructors

Example:

For the Tree data type, it generates the following function:

caseTree ::
    (PackedReader '[a] r b) ->
    (PackedReader '[Tree a, Tree a] r b) ->
    PackedReader '[Tree a] r b
caseTree leafCase nodeCase = mkPackedReader $ packed l -> do
   (tag :: Tag, packed1, l1) <- runReader reader packed l
   case tag of
       0 -> runReader leafCase packed1 l1
       1 -> runReader nodeCase packed1 l1
       _ -> fail "Bad Tag"

Generates an instance of Packable for the given type

All the parameters of each constructor should be instances of Packable

Note: The pack function simply calls the function generated by genWrite

Example

For the Tree data type, it generates the following instance:

instance (Packable a) => Packable (Tree a) where
    write = writeTree

Generates a function that serialises an applied data constructor

The function calls the functions generated by genConWrite

Example:

For the Tree data type, it generates the following functions

packLeaf :: (Packable a) => a -> Packed '[Tree a]
packLeaf n = finish (withEmptyNeeds (writeLeaf n))

packNode :: (Packable a) => Tree a -> Tree a -> Packed '[Tree a]
packNode t1 t2 = finish (withEmptyNeeds (writeNode t1 t2))

Generates a function that builds back data using already serialised fields

Example:

For the Tree data type, it generates the following functions

repackLeaf :: Needs '[] a -> Needs '[] (Tree a)
repackLeaf pval = withEmptyNeeds (startLeaf N.>> concatNeeds pval)

repackNode :: Needs '[] (Tree a) -> Needs '[] (Tree a) -> Needs '[] (Tree a)
repackNode lval rval = withEmptyNeeds (startNode N.>> concatNeeds lval N.>> concatNeeds rval)

Generates a function that serialises and writes a value into a Needs

The function simply calls the functions generated by genConWrite

Example:

For the Tree data type, it generates the following function

writeTree :: (Packable a) => Tree a -> NeedsWriter (Tree a) r t
writeTree (Leaf n) = writeConLeaf n
writeTree (Node l r) = writeConNode l r

Generates a function that serialises and write a value to a Needs. The generated function is specific to a single data constructor.

Example:

For the Tree data type, it generates the following function for the Leaf constructor

writeConLeaf :: (Packable a) => a -> 'NeedsWriter (Tree a) r t'
writeConLeaf n  = startLeaf >> write n

Generates a function that prepares a Needs to receive values from a data constructor.

Example:

For the Tree data type, it generates the following functions

startLeaf :: NeedsBuilder (Tree a ': r) t (a ': r) t
startLeaf = mkNeedsBuilder (n -> runBuilder (write (0 :: Word8) (unsafeCastNeeds n)))

startNode :: NeedsBuilder (Tree a ': r) t (Tree a ': Tree a ': r) t
startNode = mkNeedsBuilder (n -> runBuilder (write (1 :: Word8) (unsafeCastNeeds n)))

Generates an instance of Unpackable for the given type

All the parameters of each constructor should be instances of Unpackable

Note: The unpack function simply calls the function generated by genRead

Example

For the Tree data type, it generates the following instance:

instance (Unpackable a) => Unpackable (Tree a) where
   reader = readTree

Generates an function to read (i.e. deserialise) the given data type.

Example:

For the Tree data type, it generates the following function:

readTree :: (Unpackable a) => PackedReader '[Tree a] r (Tree a)
readTree = caseTree
    (reader >>= \leafContent ->
         return $ Leaf leafContent
    )

    (reader >>= \leftContent ->
     reader >>= \rightContent ->
         return $ Node leftContent rightContent
    )

Note We use bindings (>>=) intead of a do-notation, since Reader is not a monad. It's an indexed monad, meaning that the user would have to enable the QualifiedDo extenstion for it to compile.

Generates an instance of Skippable for the given type

All the parameters of each constructor should be instances of Skippable

Example

For the Tree data type, it generates the following instance:

instance (Skippable a) => Skippable (Tree a) where
    skip = skipTree

Generates an function to skip a value of the given type in a Packed

Example:

For the Tree data type, it generates the following function:

skipTree :: (Skippable a) => PackedReader '[Tree a] r ()
skipTree = caseTree
     skip
     (skipTree >> skipTree)

Byte in a Packed value to identify which data constructor is serialised