A value suitable to be typechecked using the contained extra type information.

Like Typed, but the type information is not checked. Useful to read type and value, and do the typechecking externally, as required by the caching of decodeTyped. Using typecheck', this can be promoted to a proper Typed value.

Type information stored alongside a value to be serialized, so that the recipient can do consistency checks. See TypeFormat for more detailed information on the fields.

A 5-bit hash value.

Since TypeInformation needs 3 bit to store the sort of the TypeInformation, the remaining 5 bit per Word8 can be used to store a hash value at no additional space cost. For this reason, it is important that the three rightmost bits of any Hashed5 are set to zero, i.e. (.&. 7) is id on the contained Word8.

This type intentionally doesn't have a Binary instance, since its serialization is part of the TypeInformation Binary instance exclusively.

Smart constructor for Hash5 values. Makes sure the rightmost three bits are not set by applying a bit mask to the input.

A 32-bit hash value.

A 64-bit hash value.

Construct a Typed value using the chosen type format.

Example:

value = typed Full ("hello", 1 :: Int, 2.34 :: Double)
encoded = encode value

The decode site can now verify whether decoding happens with the right type.

Create the TypeInformation to be stored inside a Typed value from a TypeRep.

Different ways of including/verifying type information of serialized messages.

Extract which TypeFormat was used to create a certain TypeInformation.

If the type is Cached', then the contained information is assumed well-formed. In the public API, this is safe to do, since only well-typed Typed values can be created in the first place.

Typecheck a Typed. Returns the (well-typed) input, or an error message if the types don't work out.

Typecheck a 'Typed\'' value so it can be used as a safe Typed value.

Extract the value of a Typed, i.e. strip off the explicit type information.

This function is safe to use for all Typed values created by the public API, since all construction sites ensure the actual type matches the contained type description.

erase (typed format x) == x

Sometimes it can be beneficial to serialize the type information in advance, so that the maybe costly serialization step does not have to be repeated on every invocation of encode. Preserialization comes at a price though, as the directly contained ByteString requires its length to be included in the final serialization, yielding a 8-byte overhead for the required Int64, and one for the tag of what was serialized ("shown or full?").

This function calculates the serialized version of TypeInformation in cases where the required 9 bytes are negligible (determined by an arbitrary threshold, currently 10*9 bytes).

Used to make encodeTyped more efficient; the source there also makes a good usage example.

TypeRep without the (internal) fingerprint.

Strip a TypeRep off the fingerprint. Inverse of unStripTypeRep.

Add a fingerprint to a TypeRep. Inverse of stripTypeRep.

Hash a TypeRep to a 5-bit digest.

Split a Word8 into the last 3 bit (used to tag the constructor) and the first 5 (data payload). Used by the Binary instance of TypeInformation.

Hash a TypeRep to a 32-bit digest.

Hash a TypeRep to a 64-bit digest.

TyCon without the (internal) fingerprint.

Strip a TyCon off the fingerprint. Inverse of unStripTyCon.

Add a fingerprint to a TyCon. Inverse of stripTyCon.