Data.Binary.Tagged.Internal

Internals for the library, exported in case you should need it. Usually, the parts you would need should be re-exported in Data.Binary.Tagged.

Data types

data Tagged a

A data type tupling together data with a TagFingerprint, representing data tagged with its type.

It's best to interface directly with data using encodeTagged, decodeTagged, etc, using tag to tag data and extractTagged to extract data from valid tagged data. This type is exported mostly when you want to specifically decode a ByteString into tagged data, and manually extract it yourself. If you are writing a framework, it is preferred to handle this for the end user.

Instances

Eq a => Eq (Tagged a)

Methods

(==) :: Tagged a -> Tagged a -> Bool

(/=) :: Tagged a -> Tagged a -> Bool

Show a => Show (Tagged a)

Methods

showsPrec :: Int -> Tagged a -> ShowS

show :: Tagged a -> String

showList :: [Tagged a] -> ShowS

Generic (Tagged a)

Associated Types

type Rep (Tagged a) :: * -> *

Methods

from :: Tagged a -> Rep (Tagged a) x

to :: Rep (Tagged a) x -> Tagged a

Binary a => Binary (Tagged a)

Methods

put :: Tagged a -> Put

get :: Get (Tagged a)

putList :: [Tagged a] -> Put

type Rep (Tagged a)

type Rep (Tagged a) = D1 (MetaData "Tagged" "Data.Binary.Tagged.Internal" "tagged-binary-0.2.0.1-Lc3n6I7VjZeMYbUEWKzSH" False) (C1 (MetaCons "Tagged" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 TagFingerprint)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))))

data TagFingerprint

A data type representing a fingerprint for a Typeable type. Ideally, this would be Internal's own Fingerprint types; however, for some reason, the fingerprints for the same data type from the same modules differ between different GHC backends. So for now, it is just a ByteString representation of the name of the type. This is literally a bad idea, and so two types with the same name but from different modules will share a non-unique TagFingerprint. Hopefully in the future when I find out a way to fix this or the GHC backend maintainers find a way to provide consistent type fingerprints, this will be fixed.

This type is mostly used for the ability to categorized Tagged items by their type.

emptyTagFP gives a TagFingerprint that will most likely never be matched by any actual tag from a real type, so can be used as a test if needed. This replaces functionality that used to come from the Default instance.

Instances

Eq TagFingerprint

Methods

(==) :: TagFingerprint -> TagFingerprint -> Bool

(/=) :: TagFingerprint -> TagFingerprint -> Bool

Ord TagFingerprint

Methods

compare :: TagFingerprint -> TagFingerprint -> Ordering

(<) :: TagFingerprint -> TagFingerprint -> Bool

(<=) :: TagFingerprint -> TagFingerprint -> Bool

(>) :: TagFingerprint -> TagFingerprint -> Bool

(>=) :: TagFingerprint -> TagFingerprint -> Bool

max :: TagFingerprint -> TagFingerprint -> TagFingerprint

min :: TagFingerprint -> TagFingerprint -> TagFingerprint

Show TagFingerprint

Methods

showsPrec :: Int -> TagFingerprint -> ShowS

show :: TagFingerprint -> String

showList :: [TagFingerprint] -> ShowS

Generic TagFingerprint

Associated Types

type Rep TagFingerprint :: * -> *

Methods

from :: TagFingerprint -> Rep TagFingerprint x

to :: Rep TagFingerprint x -> TagFingerprint

Binary TagFingerprint

Methods

put :: TagFingerprint -> Put

get :: Get TagFingerprint

putList :: [TagFingerprint] -> Put

type Rep TagFingerprint

type Rep TagFingerprint = D1 (MetaData "TagFingerprint" "Data.Binary.Tagged.Internal" "tagged-binary-0.2.0.1-Lc3n6I7VjZeMYbUEWKzSH" True) (C1 (MetaCons "TagFP" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 MD5Digest)))

Tagging and extracting data

tag :: Typeable a => a -> Tagged a

Wrap data inside a Tagged tuple.

getTagged :: Typeable a => Tagged a -> Maybe a

Extract data out of a Tagged, but only the type of the data matches the type represented by the fingerprint. It is polymorphic on its output and meant to be used when decoding a Tagged item with a desired type.

tagMatched :: Typeable a => Tagged a -> Bool

Check if the type inside the Tagged matches the fingerprint.

TagFingerprint utilities

typeFingerprint :: Typeable a => a -> TagFingerprint

Compute the Fingerprint representing a type. It is non-strict on its parameter, so passing in undefined should work if you want to just get the Fingerprint of a specific type without having data of that type on hand:

typeFingerprint (undefined :: Int)

tagFingerprint :: Tagged a -> TagFingerprint

Extract the Fingerprint out of a Tagged. Mostly used so that you can categorize and associate Tagged items; to check if a Tagged is of a desired typed, getTagged and tagMatched might be more useful.

bsFingerprint :: ByteString -> Maybe TagFingerprint

With a ByteString, expecting tagged data, returns the Fingerprint that the data is tagged with. Returns Nothing if the data is not decodable as tagged data. Might accidentally decode untagged data though!

emptyTagFP :: TagFingerprint

TagFingerprint that is meant to never be matched by any actual normal type's TagFingerprint.