-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Tagged binary serialisation.
--   
@package binary-tagged
@version 0.1.0.0


-- | Structurally tag binary serialisation stream.
--   
--   Say you have:
--   
--   <pre>
--   data Record = Record
--     { _recordFields :: HM.HashMap Text (Integer, ByteString)
--     , _recordEnabled :: Bool
--     }
--     deriving (Eq, Show, Generic)
--   
--   instance Binary Record
--   instance HasStructuralInfo Record
--   instance HasSemanticVersion Record
--   </pre>
--   
--   then you can serialise and deserialise <tt>Record</tt> values with a
--   structure tag by simply
--   
--   <pre>
--   encodeTaggedFile "cachefile" record
--   decodeTaggedFile "cachefile" :: IO Record
--   </pre>
--   
--   If structure of <tt>Record</tt> changes in between, deserialisation
--   will fail early.
module Data.Binary.Tagged

-- | <a>Binary</a> serialisable class, which tries to be less error-prone
--   to data structure changes.
--   
--   Values are serialised with header consisting of version <tt>v</tt> and
--   hash of <a>structuralInfo</a>.
newtype BinaryTagged (v :: k) a
BinaryTagged :: a -> BinaryTagged a
unBinaryTagged :: BinaryTagged a -> a
type BinaryTagged' a = BinaryTagged (SemanticVersion a) a
binaryTag :: Proxy v -> a -> BinaryTagged v a
binaryTag' :: HasSemanticVersion a => a -> BinaryTagged' a
binaryUntag :: Proxy v -> BinaryTagged v a -> a
binaryUntag' :: HasSemanticVersion a => BinaryTagged' a -> a

-- | Data type structure, with (some) nominal information.
data StructuralInfo
NominalType :: String -> StructuralInfo
NominalNewtype :: String -> StructuralInfo -> StructuralInfo
StructuralInfo :: String -> [[StructuralInfo]] -> StructuralInfo

-- | Tagged version of <a>encode</a>
taggedEncode :: (HasStructuralInfo a, HasSemanticVersion a, Binary a) => a -> ByteString

-- | Tagged version of <a>decode</a>
taggedDecode :: (HasStructuralInfo a, HasSemanticVersion a, Binary a) => ByteString -> a

-- | Tagged version of <a>decodeOrFail</a>
taggedDecodeOrFail :: (HasStructuralInfo a, HasSemanticVersion a, Binary a) => ByteString -> Either (ByteString, ByteOffset, String) (ByteString, ByteOffset, a)

-- | Tagged version of <a>encodeFile</a>
taggedEncodeFile :: (HasStructuralInfo a, HasSemanticVersion a, Binary a) => FilePath -> a -> IO ()

-- | Tagged version of <a>decodeFile</a>
taggedDecodeFile :: (HasStructuralInfo a, HasSemanticVersion a, Binary a) => FilePath -> IO a

-- | Tagged version of <a>decodeFileOrFail</a>
taggedDecodeFileOrFail :: (HasStructuralInfo a, HasSemanticVersion a, Binary a) => FilePath -> IO (Either (ByteOffset, String) a)

-- | Type class providing <a>StructuralInfo</a> for each data type.
--   
--   For regular non-recursive ADTs <a>HasStructuralInfo</a> can be derived
--   generically.
--   
--   <pre>
--   data Record = Record { a :: Int, b :: Bool, c :: [Char] } deriving (Generic)
--   instance hasStructuralInfo Record
--   </pre>
--   
--   For stable types, you can provide only type name
--   
--   <pre>
--   instance HasStructuralInfo Int where structuralInfo = ghcNominalType -- infer name from Generic information
--   instance HasStructuralInfo Integer where structuralInfo _ = NominalType "Integer"
--   </pre>
--   
--   Recursive type story is a bit sad atm. If the type structure is
--   stable, you can do:
--   
--   <pre>
--   instance HasStructuralInfo a =&gt; HasStructuralInfo [a] where structuralInfo = ghcStructuralInfo1
--   </pre>
class HasStructuralInfo a where structuralInfo = ghcStructuralInfo
structuralInfo :: HasStructuralInfo a => Proxy a -> StructuralInfo

-- | A helper type family for <tt>encodeTaggedFile</tt> and
--   <tt>decodeTaggedFile</tt>.
--   
--   The default definition is <tt><a>SemanticVersion</a> a = 0</tt>
class KnownNat (SemanticVersion a) => HasSemanticVersion (a :: *) where type family SemanticVersion a :: Nat type instance SemanticVersion a = 0

-- | Type the semantic version is serialised with.
type Version = Word32

-- | Interleaving
--   
--   <pre>
--   3 | 9  .  .  .  .
--   2 | 5  8  .  .  .
--   1 | 2  4  7 11  .
--   0 | 0  1  3  6 10
--   -----------------
--       0  1  2  3  4
--   </pre>
--   
--   This can be calculated by <tt>f x y = sum ([0..x+y]) + y</tt>
type Interleave (n :: Nat) (m :: Nat) = SumUpTo (n + m) + m
type SumUpTo (n :: Nat) = n * (n - 1)
ghcStructuralInfo :: (Generic a, All2 HasStructuralInfo (GCode a), GDatatypeInfo a, SingI (GCode a)) => Proxy a -> StructuralInfo
ghcNominalType :: (Generic a, GDatatypeInfo a) => Proxy a -> StructuralInfo
ghcStructuralInfo1 :: (Generic1 f, GDatatypeInfo (f a), HasStructuralInfo a) => Proxy (f a) -> StructuralInfo
sopStructuralInfo :: (Generic a, HasDatatypeInfo a, All2 HasStructuralInfo (Code a)) => Proxy a -> StructuralInfo
sopNominalType :: (Generic a, HasDatatypeInfo a) => Proxy a -> StructuralInfo
sopStructuralInfo1 :: (Generic (f a), HasDatatypeInfo (f a), HasStructuralInfo a) => Proxy (f a) -> StructuralInfo
sopStructuralInfoS :: (All2 HasStructuralInfo xss, SingI xss) => DatatypeInfo xss -> StructuralInfo
sopNominalTypeS :: DatatypeInfo xss -> StructuralInfo
sopStructuralInfo1S :: StructuralInfo -> DatatypeInfo xss -> StructuralInfo
structuralInfoSha1Digest :: StructuralInfo -> Digest SHA1State
structuralInfoSha1ByteStringDigest :: StructuralInfo -> ByteString
instance Eq a => Eq (BinaryTagged v a)
instance Ord a => Ord (BinaryTagged v a)
instance Show a => Show (BinaryTagged v a)
instance Read a => Read (BinaryTagged v a)
instance Functor (BinaryTagged v)
instance Foldable (BinaryTagged v)
instance Traversable (BinaryTagged v)
instance Generic (BinaryTagged v a)
instance Generic1 (BinaryTagged v)
instance Eq StructuralInfo
instance Ord StructuralInfo
instance Show StructuralInfo
instance Generic StructuralInfo
instance Datatype D1BinaryTagged
instance Constructor C1_0BinaryTagged
instance Selector S1_0_0BinaryTagged
instance Datatype D1StructuralInfo
instance Constructor C1_0StructuralInfo
instance Constructor C1_1StructuralInfo
instance Constructor C1_2StructuralInfo
instance HasSemanticVersion Value
instance HasStructuralInfo Value
instance HasSemanticVersion LocalTime
instance HasSemanticVersion TimeOfDay
instance HasSemanticVersion TimeZone
instance HasSemanticVersion Day
instance HasSemanticVersion NominalDiffTime
instance HasSemanticVersion UniversalTime
instance HasSemanticVersion DiffTime
instance HasSemanticVersion UTCTime
instance HasStructuralInfo LocalTime
instance HasStructuralInfo TimeOfDay
instance HasStructuralInfo TimeZone
instance HasStructuralInfo Day
instance HasStructuralInfo NominalDiffTime
instance HasStructuralInfo UniversalTime
instance HasStructuralInfo DiffTime
instance HasStructuralInfo UTCTime
instance HasSemanticVersion a => HasSemanticVersion (Vector a)
instance HasStructuralInfo a => HasStructuralInfo (Vector a)
instance HasSemanticVersion a => HasSemanticVersion (Vector a)
instance HasStructuralInfo a => HasStructuralInfo (Vector a)
instance HasSemanticVersion a => HasSemanticVersion (Vector a)
instance HasStructuralInfo a => HasStructuralInfo (Vector a)
instance (HasSemanticVersion i, HasSemanticVersion e, KnownNat (SemanticVersion (UArray i e))) => HasSemanticVersion (UArray i e)
instance (HasStructuralInfo i, HasStructuralInfo e) => HasStructuralInfo (UArray i e)
instance (HasSemanticVersion i, HasSemanticVersion e, KnownNat (SemanticVersion (Array i e))) => HasSemanticVersion (Array i e)
instance (HasStructuralInfo i, HasStructuralInfo e) => HasStructuralInfo (Array i e)
instance HasSemanticVersion a => HasSemanticVersion (HashSet a)
instance HasStructuralInfo a => HasStructuralInfo (HashSet a)
instance (HasSemanticVersion k, HasSemanticVersion v, KnownNat (SemanticVersion (HashMap k v))) => HasSemanticVersion (HashMap k v)
instance (HasStructuralInfo k, HasStructuralInfo v) => HasStructuralInfo (HashMap k v)
instance HasSemanticVersion a => HasSemanticVersion (Set a)
instance HasStructuralInfo a => HasStructuralInfo (Set a)
instance HasSemanticVersion a => HasSemanticVersion (Seq a)
instance HasStructuralInfo a => HasStructuralInfo (Seq a)
instance (HasSemanticVersion k, HasSemanticVersion v, KnownNat (SemanticVersion (Map k v))) => HasSemanticVersion (Map k v)
instance (HasStructuralInfo k, HasStructuralInfo v) => HasStructuralInfo (Map k v)
instance HasSemanticVersion IntSet
instance HasStructuralInfo IntSet
instance HasSemanticVersion a => HasSemanticVersion (IntMap a)
instance HasStructuralInfo a => HasStructuralInfo (IntMap a)
instance HasSemanticVersion Text
instance HasSemanticVersion Text
instance HasStructuralInfo Text
instance HasStructuralInfo Text
instance HasSemanticVersion ByteString
instance HasSemanticVersion ByteString
instance HasStructuralInfo ByteString
instance HasStructuralInfo ByteString
instance HasSemanticVersion a => HasSemanticVersion (Product a)
instance HasStructuralInfo a => HasStructuralInfo (Product a)
instance HasSemanticVersion a => HasSemanticVersion (Sum a)
instance HasStructuralInfo a => HasStructuralInfo (Sum a)
instance (HasStructuralInfo a, HasStructuralInfo b, HasStructuralInfo c, HasStructuralInfo d) => HasStructuralInfo (a, b, c, d)
instance (HasStructuralInfo a, HasStructuralInfo b, HasStructuralInfo c) => HasStructuralInfo (a, b, c)
instance (HasStructuralInfo a, HasStructuralInfo b) => HasStructuralInfo (a, b)
instance (HasSemanticVersion a, HasSemanticVersion b, KnownNat (SemanticVersion (Either a b))) => HasSemanticVersion (Either a b)
instance (HasStructuralInfo a, HasStructuralInfo b) => HasStructuralInfo (Either a b)
instance HasSemanticVersion a => HasSemanticVersion (Maybe a)
instance HasStructuralInfo a => HasStructuralInfo (Maybe a)
instance HasSemanticVersion a => HasSemanticVersion [a]
instance HasStructuralInfo a => HasStructuralInfo [a]
instance HasStructuralInfo Word64
instance HasStructuralInfo Word32
instance HasStructuralInfo Word16
instance HasStructuralInfo Word8
instance HasStructuralInfo Int64
instance HasStructuralInfo Int32
instance HasStructuralInfo Int16
instance HasStructuralInfo Int8
instance HasStructuralInfo Integer
instance HasStructuralInfo Int
instance HasStructuralInfo Char
instance HasStructuralInfo Bool
instance HasSemanticVersion StructuralInfo
instance HasStructuralInfo StructuralInfo
instance Binary StructuralInfo
instance (Binary a, HasStructuralInfo a, KnownNat v) => Binary (BinaryTagged v a)
instance Monoid a => Monoid (BinaryTagged v a)
instance Monad (BinaryTagged v)
instance Applicative (BinaryTagged v)