    {-# LANGUAGE BangPatterns        #-}
    {-# LANGUAGE CPP                 #-}
    {-# LANGUAGE DefaultSignatures   #-}
    {-# LANGUAGE FlexibleContexts    #-}
    {-# LANGUAGE PolyKinds           #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE TypeFamilies        #-}
    {-# LANGUAGE TypeOperators       #-}

    -- |
    -- Module      : Codec.Serialise.Class
    -- Copyright   : (c) Duncan Coutts 2015-2017
    -- License     : BSD3-style (see LICENSE.txt)
    --
    -- Maintainer  : duncan@community.haskell.org
    -- Stability   : experimental
    -- Portability : non-portable (GHC extensions)
    --
    -- The @'Serialise'@ class allows you to encode a given type into a
    -- CBOR object, or decode a CBOR object into the user-specified type.
    --
    module Codec.Serialise.Class
     ( -- * The Serialise class
       Serialise(..)
     , GSerialiseEncode(..)
     , GSerialiseDecode(..)
     , GSerialiseProd(..)
     , GSerialiseSum(..)
     , encodeVector
     , decodeVector
     , encodeContainerSkel
     , encodeMapSkel
     , decodeMapSkel
     ) where

    import           Control.Applicative

    import           Control.Monad
    import           Data.Char
    import           Data.Hashable
    import           Data.Int
    import           Data.Monoid
    import           Data.Proxy
    import           Data.Version
    import           Data.Word
    import           Data.Complex
    import           Data.Fixed
    import           Data.Ratio
    import           Data.Ord

    #if MIN_VERSION_base(4,8,0)
    import           Numeric.Natural
    import           Data.Functor.Identity
    import           Data.Void                           (Void, absurd)
    #endif

    #if MIN_VERSION_base(4,9,0)
    import qualified Data.Semigroup                      as Semigroup
    import qualified Data.List.NonEmpty                  as NonEmpty
    #endif

    import qualified Data.Foldable                       as Foldable
    import qualified Data.ByteString                     as BS
    import qualified Data.ByteString.Short.Internal      as BSS
    import qualified Data.Text                           as Text

    -- TODO FIXME: more instances
    --import qualified Data.Array                          as Array
    --import qualified Data.Array.Unboxed                  as UArray
    import qualified Data.ByteString.Lazy                as BS.Lazy
    import qualified Data.Map                            as Map
    import qualified Data.Sequence                       as Sequence
    import qualified Data.Set                            as Set
    import qualified Data.Strict                         as Strict
    import qualified Data.IntSet                         as IntSet
    import qualified Data.IntMap                         as IntMap
    import qualified Data.HashSet                        as HashSet
    import qualified Data.HashMap.Strict                 as HashMap
    import qualified Data.These                          as These
    import qualified Data.Tree                           as Tree
    import qualified Data.Primitive.ByteArray            as Prim
    import qualified Data.Vector                         as Vector
    import qualified Data.Vector.Unboxed                 as Vector.Unboxed
    import qualified Data.Vector.Storable                as Vector.Storable
    import qualified Data.Vector.Primitive               as Vector.Primitive
    import qualified Data.Vector.Generic                 as Vector.Generic
    import qualified Data.Text.Lazy                      as Text.Lazy
    import           Foreign.C.Types
    import qualified Numeric.Half                        as Half

    import           Data.Time                           (UTCTime (..), addUTCTime)
    import           Data.Time.Calendar                  (fromGregorian)
    import           Data.Time.Clock.POSIX               (POSIXTime, utcTimeToPOSIXSeconds,
                                                          posixSecondsToUTCTime)
    #if MIN_VERSION_time(1,5,0)
    import           Data.Time.Format                    (defaultTimeLocale, parseTimeM)
    #else
    import           Data.Time.Format                    (parseTime)
    import           System.Locale                       (defaultTimeLocale)
    #endif
    import           System.Exit                         (ExitCode(..))

    import           Prelude hiding (decodeFloat, encodeFloat, foldr)
    import qualified Prelude
    #if MIN_VERSION_base(4,16,0)
    import           GHC.Exts (Levity(..))
    #endif
    #if MIN_VERSION_base(4,10,0)
    import           Type.Reflection
    import           Type.Reflection.Unsafe
    import           GHC.Fingerprint
    import           GHC.Exts (VecCount(..), VecElem(..), RuntimeRep(..))
    import           Data.Kind (Type)
    #else
    import           Data.Typeable.Internal
    #endif
    import           GHC.Generics

    import           Codec.CBOR.Decoding
    import           Codec.CBOR.Encoding
    import           Codec.CBOR.Term
    import           Codec.Serialise.Internal.GeneralisedUTF8
    import qualified Codec.CBOR.ByteArray                as BA
    import qualified Codec.CBOR.ByteArray.Sliced         as BAS

    --------------------------------------------------------------------------------
    -- The Serialise class

    -- | Types that are instances of the @'Serialise'@ class allow values
    -- to be quickly encoded or decoded directly to a CBOR representation,
    -- for object transmission or storage.
    --
    -- @since 0.2.0.0
    class Serialise a where
        -- | Definition for encoding a given type into a binary
        -- representation, using the @'Encoding'@ @'Monoid'@.
        --
        -- @since 0.2.0.0
        encode  :: a -> Encoding
        default encode :: (Generic a, GSerialiseEncode (Rep a)) => a -> Encoding
        encode = Rep a (ZonkAny 2) -> Encoding
    forall a. Rep a a -> Encoding
    forall {k} (f :: k -> *) (a :: k).
    GSerialiseEncode f =>
    f a -> Encoding
    gencode (Rep a (ZonkAny 2) -> Encoding)
    -> (a -> Rep a (ZonkAny 2)) -> a -> Encoding
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Rep a (ZonkAny 2)
    forall x. a -> Rep a x
    forall a x. Generic a => a -> Rep a x
    from

        -- | Definition of a given @'Decoder'@ for a type.
        --
        -- @since 0.2.0.0
        decode  :: Decoder s a
        default decode :: (Generic a, GSerialiseDecode (Rep a)) => Decoder s a
        decode = Rep a (ZonkAny 3) -> a
    forall a x. Generic a => Rep a x -> a
    forall x. Rep a x -> a
    to (Rep a (ZonkAny 3) -> a)
    -> Decoder s (Rep a (ZonkAny 3)) -> Decoder s a
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s (Rep a (ZonkAny 3))
    forall s a. Decoder s (Rep a a)
    forall {k} (f :: k -> *) s (a :: k).
    GSerialiseDecode f =>
    Decoder s (f a)
    gdecode

        -- | Utility to support specialised encoding for some list type -
        -- used for @'Char'@/@'String'@ instances in this package.
        --
        -- @since 0.2.0.0
        encodeList :: [a] -> Encoding
        encodeList = [a] -> Encoding
    forall a. Serialise a => [a] -> Encoding
    defaultEncodeList

        -- | Utility to support specialised decoding for some list type -
        -- used for @'Char'@/@'String'@ instances in this package.
        --
        -- @since 0.2.0.0
        decodeList :: Decoder s [a]
        decodeList = Decoder s [a]
    forall a s. Serialise a => Decoder s [a]
    defaultDecodeList

    -- | @since 0.2.0.0
    instance Serialise Term where
      encode :: Term -> Encoding
    encode = Term -> Encoding
    encodeTerm
      decode :: forall s. Decoder s Term
    decode = Decoder s Term
    forall s. Decoder s Term
    decodeTerm

    --------------------------------------------------------------------------------
    -- Special list business

    -- | @since 0.2.0.0
    instance Serialise a => Serialise [a] where
        encode :: [a] -> Encoding
    encode = [a] -> Encoding
    forall a. Serialise a => [a] -> Encoding
    encodeList
        decode :: forall s. Decoder s [a]
    decode = Decoder s [a]
    forall s. Decoder s [a]
    forall a s. Serialise a => Decoder s [a]
    decodeList

    -- | Default @'Encoding'@ for list types.
    --
    -- @since 0.2.0.0
    defaultEncodeList :: Serialise a => [a] -> Encoding
    defaultEncodeList :: forall a. Serialise a => [a] -> Encoding
    defaultEncodeList [] = Word -> Encoding
    encodeListLen Word
    0
    defaultEncodeList [a]
    xs = Encoding
    encodeListLenIndef
                        Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> (a -> Encoding -> Encoding) -> Encoding -> [a] -> Encoding
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    Prelude.foldr (\a
    x Encoding
    r -> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    x Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Encoding
    r) Encoding
    encodeBreak [a]
    xs

    -- | Default @'Decoder'@ for list types.
    --
    -- @since 0.2.0.0
    defaultDecodeList :: Serialise a => Decoder s [a]
    defaultDecodeList :: forall a s. Serialise a => Decoder s [a]
    defaultDecodeList = do
        mn <- Decoder s (Maybe Int)
    forall s. Decoder s (Maybe Int)
    decodeListLenOrIndef
        case mn of
          Maybe Int
    Nothing -> ([a] -> a -> [a])
    -> [a] -> ([a] -> [a]) -> Decoder s a -> Decoder s [a]
    forall r a r' s.
    (r -> a -> r) -> r -> (r -> r') -> Decoder s a -> Decoder s r'
    decodeSequenceLenIndef ((a -> [a] -> [a]) -> [a] -> a -> [a]
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (:)) [] [a] -> [a]
    forall a. [a] -> [a]
    reverse   Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
          Just Int
    n  -> ([a] -> a -> [a])
    -> [a] -> ([a] -> [a]) -> Int -> Decoder s a -> Decoder s [a]
    forall r a r' s.
    (r -> a -> r)
    -> r -> (r -> r') -> Int -> Decoder s a -> Decoder s r'
    decodeSequenceLenN     ((a -> [a] -> [a]) -> [a] -> a -> [a]
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (:)) [] [a] -> [a]
    forall a. [a] -> [a]
    reverse Int
    n Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode

    --------------------------------------------------------------------------------
    -- Another case: NonEmpty lists

    #if MIN_VERSION_base(4,9,0)
    -- | @since 0.2.0.0
    instance Serialise a => Serialise (NonEmpty.NonEmpty a) where
      encode :: NonEmpty a -> Encoding
    encode = [a] -> Encoding
    forall a. Serialise a => [a] -> Encoding
    defaultEncodeList ([a] -> Encoding) -> (NonEmpty a -> [a]) -> NonEmpty a -> Encoding
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NonEmpty a -> [a]
    forall a. NonEmpty a -> [a]
    NonEmpty.toList
      decode :: forall s. Decoder s (NonEmpty a)
    decode = do
        l <- Decoder s [a]
    forall a s. Serialise a => Decoder s [a]
    defaultDecodeList
        case NonEmpty.nonEmpty l of
          Maybe (NonEmpty a)
    Nothing -> String -> Decoder s (NonEmpty a)
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "Expected a NonEmpty list, but an empty list was found!"
          Just NonEmpty a
    xs -> NonEmpty a -> Decoder s (NonEmpty a)
    forall a. a -> Decoder s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return NonEmpty a
    xs
    #endif

    --------------------------------------------------------------------------------
    -- Primitive and integral instances

    #if MIN_VERSION_base(4,8,0)
    -- | @since 0.2.4.0
    instance Serialise Void where
        encode :: Void -> Encoding
    encode = Void -> Encoding
    forall a. Void -> a
    absurd
        decode :: forall s. Decoder s Void
    decode = String -> Decoder s Void
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "tried to decode void"
    #endif

    -- | @since 0.2.0.0
    instance Serialise () where
        encode :: () -> Encoding
    encode = Encoding -> () -> Encoding
    forall a b. a -> b -> a
    const Encoding
    encodeNull
        decode :: forall s. Decoder s ()
    decode = Decoder s ()
    forall s. Decoder s ()
    decodeNull

    -- | @since 0.2.0.0
    instance Serialise Bool where
        encode :: Bool -> Encoding
    encode = Bool -> Encoding
    encodeBool
        decode :: forall s. Decoder s Bool
    decode = Decoder s Bool
    forall s. Decoder s Bool
    decodeBool

    -- | @since 0.2.0.0
    instance Serialise Int where
        encode :: Int -> Encoding
    encode = Int -> Encoding
    encodeInt
        decode :: forall s. Decoder s Int
    decode = Decoder s Int
    forall s. Decoder s Int
    decodeInt

    -- | @since 0.2.0.0
    instance Serialise Int8 where
        encode :: Int8 -> Encoding
    encode = Int8 -> Encoding
    encodeInt8
        decode :: forall s. Decoder s Int8
    decode = Decoder s Int8
    forall s. Decoder s Int8
    decodeInt8

    -- | @since 0.2.0.0
    instance Serialise Int16 where
        encode :: Int16 -> Encoding
    encode = Int16 -> Encoding
    encodeInt16
        decode :: forall s. Decoder s Int16
    decode = Decoder s Int16
    forall s. Decoder s Int16
    decodeInt16

    -- | @since 0.2.0.0
    instance Serialise Int32 where
        encode :: Int32 -> Encoding
    encode = Int32 -> Encoding
    encodeInt32
        decode :: forall s. Decoder s Int32
    decode = Decoder s Int32
    forall s. Decoder s Int32
    decodeInt32

    -- | @since 0.2.0.0
    instance Serialise Int64 where
        encode :: Int64 -> Encoding
    encode = Int64 -> Encoding
    encodeInt64
        decode :: forall s. Decoder s Int64
    decode = Decoder s Int64
    forall s. Decoder s Int64
    decodeInt64

    -- | @since 0.2.0.0
    instance Serialise Word where
        encode :: Word -> Encoding
    encode = Word -> Encoding
    encodeWord
        decode :: forall s. Decoder s Word
    decode = Decoder s Word
    forall s. Decoder s Word
    decodeWord

    -- | @since 0.2.0.0
    instance Serialise Word8 where
        encode :: Word8 -> Encoding
    encode = Word8 -> Encoding
    encodeWord8
        decode :: forall s. Decoder s Word8
    decode = Decoder s Word8
    forall s. Decoder s Word8
    decodeWord8

    -- | @since 0.2.0.0
    instance Serialise Word16 where
        encode :: Word16 -> Encoding
    encode = Word16 -> Encoding
    encodeWord16
        decode :: forall s. Decoder s Word16
    decode = Decoder s Word16
    forall s. Decoder s Word16
    decodeWord16

    -- | @since 0.2.0.0
    instance Serialise Word32 where
        encode :: Word32 -> Encoding
    encode = Word32 -> Encoding
    encodeWord32
        decode :: forall s. Decoder s Word32
    decode = Decoder s Word32
    forall s. Decoder s Word32
    decodeWord32

    -- | @since 0.2.0.0
    instance Serialise Word64 where
        encode :: Word64 -> Encoding
    encode = Word64 -> Encoding
    encodeWord64
        decode :: forall s. Decoder s Word64
    decode = Decoder s Word64
    forall s. Decoder s Word64
    decodeWord64

    -- | @since 0.2.0.0
    instance Serialise Integer where
        encode :: Integer -> Encoding
    encode = Integer -> Encoding
    encodeInteger
        decode :: forall s. Decoder s Integer
    decode = Decoder s Integer
    forall s. Decoder s Integer
    decodeInteger

    #if MIN_VERSION_base(4,8,0)
    -- | @since 0.2.0.0
    instance Serialise Natural where
        encode :: Natural -> Encoding
    encode = Integer -> Encoding
    encodeInteger (Integer -> Encoding)
    -> (Natural -> Integer) -> Natural -> Encoding
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Natural -> Integer
    forall a. Integral a => a -> Integer
    toInteger
        decode :: forall s. Decoder s Natural
    decode = do
          n <- Decoder s Integer
    forall s. Decoder s Integer
    decodeInteger
          if n >= 0
            then return (fromInteger n)
            else fail "Expected non-negative Natural; but got a negative number"
    #endif

    -- | @since 0.2.0.0
    instance Serialise Float where
        encode :: Float -> Encoding
    encode = Float -> Encoding
    encodeFloat
        decode :: forall s. Decoder s Float
    decode = Decoder s Float
    forall s. Decoder s Float
    decodeFloat

    -- | @since 0.2.0.0
    instance Serialise Double where
        encode :: Double -> Encoding
    encode = Double -> Encoding
    encodeDouble
        decode :: forall s. Decoder s Double
    decode = Decoder s Double
    forall s. Decoder s Double
    decodeDouble

    -- | @since 0.2.0.0
    instance Serialise Half.Half where
        encode :: Half -> Encoding
    encode = Float -> Encoding
    encodeFloat16 (Float -> Encoding) -> (Half -> Float) -> Half -> Encoding
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Half -> Float
    Half.fromHalf
        decode :: forall s. Decoder s Half
    decode = (Float -> Half) -> Decoder s Float -> Decoder s Half
    forall a b. (a -> b) -> Decoder s a -> Decoder s b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Float -> Half
    Half.toHalf Decoder s Float
    forall s. Decoder s Float
    decodeFloat

    --------------------------------------------------------------------------------
    -- Core types

    #if MIN_VERSION_base(4,7,0)
    -- | Values are serialised in units of least precision represented as
    --   @Integer@.
    --
    -- @since 0.2.0.0
    instance Serialise (Fixed e) where
        encode :: Fixed e -> Encoding
    encode (MkFixed Integer
    i) = Integer -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Integer
    i
        decode :: forall s. Decoder s (Fixed e)
    decode = Integer -> Fixed e
    forall k (a :: k). Integer -> Fixed a
    MkFixed (Integer -> Fixed e) -> Decoder s Integer -> Decoder s (Fixed e)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Integer
    forall s. Decoder s Integer
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise (Proxy a) where
        encode :: Proxy a -> Encoding
    encode Proxy a
    _ = Encoding
    encodeNull
        decode :: forall s. Decoder s (Proxy a)
    decode   = Proxy a
    forall {k} (t :: k). Proxy t
    Proxy Proxy a -> Decoder s () -> Decoder s (Proxy a)
    forall a b. a -> Decoder s b -> Decoder s a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Decoder s ()
    forall s. Decoder s ()
    decodeNull
    #endif

    -- | @since 0.2.0.0
    instance Serialise Char where
        -- Here we've taken great pains to ensure that surrogate characters, which
        -- are not representable in UTF-8 yet still admitted by Char,
        -- round-trip properly. We scan the encoded characters during encoding
        -- looking for surrogates; if we find any we encode the string as a
        -- a list of code-points encoded as words. This is slow, but should be rare.
        encode :: Char -> Encoding
    encode Char
    c
          | Char -> Bool
    isSurrogate Char
    c = Word -> Encoding
    encodeWord (Int -> Word
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word) -> Int -> Word
    forall a b. (a -> b) -> a -> b
    $ Char -> Int
    ord Char
    c)
          | Bool
    otherwise     = Text -> Encoding
    encodeString (Char -> Text
    Text.singleton Char
    c)
        decode :: forall s. Decoder s Char
    decode = do ty <- Decoder s TokenType
    forall s. Decoder s TokenType
    peekTokenType
                    case ty of
                      TokenType
    TypeUInt -> Int -> Char
    chr (Int -> Char) -> (Word -> Int) -> Word -> Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word -> Char) -> Decoder s Word -> Decoder s Char
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Word
    forall s. Decoder s Word
    decodeWord
                      TokenType
    TypeString -> do
                        t <- Decoder s Text
    forall s. Decoder s Text
    decodeString
                        if Text.length t == 1
                          then return $! Text.head t
                          else fail "expected a single char, found a string"
                      TokenType
    _ -> String -> Decoder s Char
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "expected a word or string"

        -- For [Char]/String we have a special encoding
        encodeList :: String -> Encoding
    encodeList String
    cs =
            case String -> (SlicedByteArray, UTF8Encoding)
    encodeGenUTF8 String
    cs of
              (SlicedByteArray
    ba, UTF8Encoding
    ConformantUTF8)  -> SlicedByteArray -> Encoding
    encodeUtf8ByteArray SlicedByteArray
    ba
              (SlicedByteArray
    ba, UTF8Encoding
    GeneralisedUTF8) -> SlicedByteArray -> Encoding
    encodeByteArray SlicedByteArray
    ba
        decodeList :: forall s. Decoder s String
    decodeList    = do
            ty <- Decoder s TokenType
    forall s. Decoder s TokenType
    peekTokenType
            case ty of
              TokenType
    TypeBytes  -> ByteArray -> String
    decodeGenUTF8 (ByteArray -> String)
    -> (ByteArray -> ByteArray) -> ByteArray -> String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteArray -> ByteArray
    BA.unBA (ByteArray -> String) -> Decoder s ByteArray -> Decoder s String
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s ByteArray
    forall s. Decoder s ByteArray
    decodeByteArray
              TokenType
    TypeString -> do
                  txt <- Decoder s Text
    forall s. Decoder s Text
    decodeString
                  return (Text.unpack txt) -- unpack lazily
              TokenType
    _          -> String -> Decoder s String
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "expected a list or string"

    -- | @since 0.2.0.0
    instance Serialise Text.Text where
        encode :: Text -> Encoding
    encode = Text -> Encoding
    encodeString
        decode :: forall s. Decoder s Text
    decode = Decoder s Text
    forall s. Decoder s Text
    decodeString

    -- | @since 0.2.0.0
    instance Serialise BS.ByteString where
        encode :: ByteString -> Encoding
    encode = ByteString -> Encoding
    encodeBytes
        decode :: forall s. Decoder s ByteString
    decode = Decoder s ByteString
    forall s. Decoder s ByteString
    decodeBytes

    -- | @since 0.2.0.0
    instance Serialise BSS.ShortByteString where
        encode :: ShortByteString -> Encoding
    encode sbs :: ShortByteString
    sbs@(BSS.SBS ByteArray#
    ba) =
            SlicedByteArray -> Encoding
    encodeByteArray (SlicedByteArray -> Encoding) -> SlicedByteArray -> Encoding
    forall a b. (a -> b) -> a -> b
    $ ByteArray -> Int -> Int -> SlicedByteArray
    BAS.SBA (ByteArray# -> ByteArray
    Prim.ByteArray ByteArray#
    ba) Int
    0 (ShortByteString -> Int
    BSS.length ShortByteString
    sbs)
        decode :: forall s. Decoder s ShortByteString
    decode = do
            BA.BA (Prim.ByteArray ba) <- Decoder s ByteArray
    forall s. Decoder s ByteArray
    decodeByteArray
            return $ BSS.SBS ba

    encodeChunked :: Serialise c
                  => Encoding
                  -> ((c -> Encoding -> Encoding) -> Encoding -> a -> Encoding)
                  -> a
                  -> Encoding
    encodeChunked :: forall c a.
    Serialise c =>
    Encoding
    -> ((c -> Encoding -> Encoding) -> Encoding -> a -> Encoding)
    -> a
    -> Encoding
    encodeChunked Encoding
    encodeIndef (c -> Encoding -> Encoding) -> Encoding -> a -> Encoding
    foldrChunks a
    a =
        Encoding
    encodeIndef
     Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> (c -> Encoding -> Encoding) -> Encoding -> a -> Encoding
    foldrChunks (\c
    x Encoding
    r -> c -> Encoding
    forall a. Serialise a => a -> Encoding
    encode c
    x Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Encoding
    r) Encoding
    encodeBreak a
    a

    decodeChunked :: Serialise c => Decoder s () -> ([c] -> a) -> Decoder s a
    decodeChunked :: forall c s a.
    Serialise c =>
    Decoder s () -> ([c] -> a) -> Decoder s a
    decodeChunked Decoder s ()
    decodeIndef [c] -> a
    fromChunks = do
      Decoder s ()
    decodeIndef
      ([c] -> c -> [c])
    -> [c] -> ([c] -> a) -> Decoder s c -> Decoder s a
    forall r a r' s.
    (r -> a -> r) -> r -> (r -> r') -> Decoder s a -> Decoder s r'
    decodeSequenceLenIndef ((c -> [c] -> [c]) -> [c] -> c -> [c]
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (:)) [] ([c] -> a
    fromChunks ([c] -> a) -> ([c] -> [c]) -> [c] -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [c] -> [c]
    forall a. [a] -> [a]
    reverse) Decoder s c
    forall s. Decoder s c
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise Text.Lazy.Text where
        encode :: Text -> Encoding
    encode = Encoding
    -> ((Text -> Encoding -> Encoding) -> Encoding -> Text -> Encoding)
    -> Text
    -> Encoding
    forall c a.
    Serialise c =>
    Encoding
    -> ((c -> Encoding -> Encoding) -> Encoding -> a -> Encoding)
    -> a
    -> Encoding
    encodeChunked Encoding
    encodeStringIndef (Text -> Encoding -> Encoding) -> Encoding -> Text -> Encoding
    forall a. (Text -> a -> a) -> a -> Text -> a
    Text.Lazy.foldrChunks
        decode :: forall s. Decoder s Text
    decode = Decoder s () -> ([Text] -> Text) -> Decoder s Text
    forall c s a.
    Serialise c =>
    Decoder s () -> ([c] -> a) -> Decoder s a
    decodeChunked Decoder s ()
    forall s. Decoder s ()
    decodeStringIndef [Text] -> Text
    Text.Lazy.fromChunks

    -- | @since 0.2.0.0
    instance Serialise BS.Lazy.ByteString where
        encode :: ByteString -> Encoding
    encode = Encoding
    -> ((ByteString -> Encoding -> Encoding)
        -> Encoding -> ByteString -> Encoding)
    -> ByteString
    -> Encoding
    forall c a.
    Serialise c =>
    Encoding
    -> ((c -> Encoding -> Encoding) -> Encoding -> a -> Encoding)
    -> a
    -> Encoding
    encodeChunked Encoding
    encodeBytesIndef (ByteString -> Encoding -> Encoding)
    -> Encoding -> ByteString -> Encoding
    forall a. (ByteString -> a -> a) -> a -> ByteString -> a
    BS.Lazy.foldrChunks
        decode :: forall s. Decoder s ByteString
    decode = Decoder s ()
    -> ([ByteString] -> ByteString) -> Decoder s ByteString
    forall c s a.
    Serialise c =>
    Decoder s () -> ([c] -> a) -> Decoder s a
    decodeChunked Decoder s ()
    forall s. Decoder s ()
    decodeBytesIndef [ByteString] -> ByteString
    BS.Lazy.fromChunks

    -- | @since 0.2.0.0
    instance Serialise a => Serialise (Const a b) where
        encode :: Const a b -> Encoding
    encode (Const a
    a) = a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    a
        decode :: forall s. Decoder s (Const a b)
    decode = a -> Const a b
    forall {k} a (b :: k). a -> Const a b
    Const (a -> Const a b) -> Decoder s a -> Decoder s (Const a b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise a => Serialise (ZipList a) where
        encode :: ZipList a -> Encoding
    encode (ZipList [a]
    xs) = [a] -> Encoding
    forall a. Serialise a => a -> Encoding
    encode [a]
    xs
        decode :: forall s. Decoder s (ZipList a)
    decode = [a] -> ZipList a
    forall a. [a] -> ZipList a
    ZipList ([a] -> ZipList a) -> Decoder s [a] -> Decoder s (ZipList a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s [a]
    forall s. Decoder s [a]
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance (Serialise a, Integral a) => Serialise (Ratio a) where
        encode :: Ratio a -> Encoding
    encode Ratio a
    a = Word -> Encoding
    encodeListLen Word
    2
                Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode (Ratio a -> a
    forall a. Ratio a -> a
    numerator Ratio a
    a)
                Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode (Ratio a -> a
    forall a. Ratio a -> a
    denominator Ratio a
    a)
        decode :: forall s. Decoder s (Ratio a)
    decode = do Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    2
                    !a <- Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
                    !b <- decode
                    return $ a % b

    -- | @since 0.2.0.0
    instance Serialise a => Serialise (Complex a) where
        encode :: Complex a -> Encoding
    encode (a
    r :+ a
    i) = Word -> Encoding
    encodeListLen Word
    2
                       Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    r
                       Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    i
        decode :: forall s. Decoder s (Complex a)
    decode = do Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    2
                    !r <- Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
                    !i <- decode
                    return $ r :+ i

    -- | @since 0.2.0.0
    instance Serialise Ordering where
        encode :: Ordering -> Encoding
    encode Ordering
    a = Word -> Encoding
    encodeListLen Word
    1
                Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord (case Ordering
    a of Ordering
    LT -> Word
    0
                                         Ordering
    EQ -> Word
    1
                                         Ordering
    GT -> Word
    2)
        decode :: forall s. Decoder s Ordering
    decode = do
          Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    1
          t <- Decoder s Word
    forall s. Decoder s Word
    decodeWord
          case t of
            Word
    0 -> Ordering -> Decoder s Ordering
    forall a. a -> Decoder s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ordering
    LT
            Word
    1 -> Ordering -> Decoder s Ordering
    forall a. a -> Decoder s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ordering
    EQ
            Word
    2 -> Ordering -> Decoder s Ordering
    forall a. a -> Decoder s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ordering
    GT
            Word
    _ -> String -> Decoder s Ordering
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "unexpected tag"

    -- | @since 0.2.0.0
    instance Serialise a => Serialise (Down a) where
        encode :: Down a -> Encoding
    encode (Down a
    a) = a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    a
        decode :: forall s. Decoder s (Down a)
    decode = a -> Down a
    forall a. a -> Down a
    Down (a -> Down a) -> Decoder s a -> Decoder s (Down a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise a => Serialise (Dual a) where
        encode :: Dual a -> Encoding
    encode (Dual a
    a) = a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    a
        decode :: forall s. Decoder s (Dual a)
    decode = a -> Dual a
    forall a. a -> Dual a
    Dual (a -> Dual a) -> Decoder s a -> Decoder s (Dual a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise All where
        encode :: All -> Encoding
    encode (All Bool
    b) = Bool -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Bool
    b
        decode :: forall s. Decoder s All
    decode = Bool -> All
    All (Bool -> All) -> Decoder s Bool -> Decoder s All
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Bool
    forall s. Decoder s Bool
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise Any where
        encode :: Any -> Encoding
    encode (Any Bool
    b) = Bool -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Bool
    b
        decode :: forall s. Decoder s Any
    decode = Bool -> Any
    Any (Bool -> Any) -> Decoder s Bool -> Decoder s Any
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Bool
    forall s. Decoder s Bool
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise a => Serialise (Sum a) where
        encode :: Sum a -> Encoding
    encode (Sum a
    b) = a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    b
        decode :: forall s. Decoder s (Sum a)
    decode = a -> Sum a
    forall a. a -> Sum a
    Sum (a -> Sum a) -> Decoder s a -> Decoder s (Sum a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise a => Serialise (Product a) where
        encode :: Product a -> Encoding
    encode (Product a
    b) = a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    b
        decode :: forall s. Decoder s (Product a)
    decode = a -> Product a
    forall a. a -> Product a
    Product (a -> Product a) -> Decoder s a -> Decoder s (Product a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise a => Serialise (First a) where
        encode :: First a -> Encoding
    encode (First Maybe a
    b) = Maybe a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Maybe a
    b
        decode :: forall s. Decoder s (First a)
    decode = Maybe a -> First a
    forall a. Maybe a -> First a
    First (Maybe a -> First a) -> Decoder s (Maybe a) -> Decoder s (First a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s (Maybe a)
    forall s. Decoder s (Maybe a)
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise a => Serialise (Last a) where
        encode :: Last a -> Encoding
    encode (Last Maybe a
    b) = Maybe a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Maybe a
    b
        decode :: forall s. Decoder s (Last a)
    decode = Maybe a -> Last a
    forall a. Maybe a -> Last a
    Last (Maybe a -> Last a) -> Decoder s (Maybe a) -> Decoder s (Last a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s (Maybe a)
    forall s. Decoder s (Maybe a)
    forall a s. Serialise a => Decoder s a
    decode

    #if MIN_VERSION_base(4,8,0)
    -- | @since 0.2.0.0
    instance Serialise (f a) => Serialise (Alt f a) where
        encode :: Alt f a -> Encoding
    encode (Alt f a
    b) = f a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode f a
    b
        decode :: forall s. Decoder s (Alt f a)
    decode = f a -> Alt f a
    forall {k} (f :: k -> *) (a :: k). f a -> Alt f a
    Alt (f a -> Alt f a) -> Decoder s (f a) -> Decoder s (Alt f a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s (f a)
    forall s. Decoder s (f a)
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise a => Serialise (Identity a) where
        encode :: Identity a -> Encoding
    encode (Identity a
    b) = a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    b
        decode :: forall s. Decoder s (Identity a)
    decode = a -> Identity a
    forall a. a -> Identity a
    Identity (a -> Identity a) -> Decoder s a -> Decoder s (Identity a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
    #endif

    -- | @since 0.2.0.0
    instance Serialise ExitCode where
        encode :: ExitCode -> Encoding
    encode ExitCode
    ExitSuccess     = Word -> Encoding
    encodeListLen Word
    1
                              Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    0
        encode (ExitFailure Int
    i) = Word -> Encoding
    encodeListLen Word
    2
                              Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    1
                              Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Int -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Int
    i
        decode :: forall s. Decoder s ExitCode
    decode = do
          n <- Decoder s Int
    forall s. Decoder s Int
    decodeListLen
          case n of
            Int
    1 -> do t <- Decoder s Word
    forall s. Decoder s Word
    decodeWord
                    case t of
                      Word
    0 -> ExitCode -> Decoder s ExitCode
    forall a. a -> Decoder s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ExitCode
    ExitSuccess
                      Word
    _ -> String -> Decoder s ExitCode
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "unexpected tag"
            Int
    2 -> do t <- Decoder s Word
    forall s. Decoder s Word
    decodeWord
                    case t of
                      Word
    1 -> () -> Decoder s ()
    forall a. a -> Decoder s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
                      Word
    _ -> String -> Decoder s ()
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "unexpected tag"
                    !i <- decode
                    return $ ExitFailure i
            Int
    _ -> String -> Decoder s ExitCode
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "Bad list length"

    -- Semigroup instances for GHC 8.0+
    #if MIN_VERSION_base(4,9,0)
    -- | @since 0.2.0.0
    instance Serialise a => Serialise (Semigroup.Min a) where
      encode :: Min a -> Encoding
    encode = a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode (a -> Encoding) -> (Min a -> a) -> Min a -> Encoding
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Min a -> a
    forall a. Min a -> a
    Semigroup.getMin
      decode :: forall s. Decoder s (Min a)
    decode = (a -> Min a) -> Decoder s a -> Decoder s (Min a)
    forall a b. (a -> b) -> Decoder s a -> Decoder s b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> Min a
    forall a. a -> Min a
    Semigroup.Min Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise a => Serialise (Semigroup.Max a) where
      encode :: Max a -> Encoding
    encode = a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode (a -> Encoding) -> (Max a -> a) -> Max a -> Encoding
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Max a -> a
    forall a. Max a -> a
    Semigroup.getMax
      decode :: forall s. Decoder s (Max a)
    decode = (a -> Max a) -> Decoder s a -> Decoder s (Max a)
    forall a b. (a -> b) -> Decoder s a -> Decoder s b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> Max a
    forall a. a -> Max a
    Semigroup.Max Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise a => Serialise (Semigroup.First a) where
      encode :: First a -> Encoding
    encode = a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode (a -> Encoding) -> (First a -> a) -> First a -> Encoding
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . First a -> a
    forall a. First a -> a
    Semigroup.getFirst
      decode :: forall s. Decoder s (First a)
    decode = (a -> First a) -> Decoder s a -> Decoder s (First a)
    forall a b. (a -> b) -> Decoder s a -> Decoder s b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> First a
    forall a. a -> First a
    Semigroup.First Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise a => Serialise (Semigroup.Last a) where
      encode :: Last a -> Encoding
    encode = a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode (a -> Encoding) -> (Last a -> a) -> Last a -> Encoding
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Last a -> a
    forall a. Last a -> a
    Semigroup.getLast
      decode :: forall s. Decoder s (Last a)
    decode = (a -> Last a) -> Decoder s a -> Decoder s (Last a)
    forall a b. (a -> b) -> Decoder s a -> Decoder s b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> Last a
    forall a. a -> Last a
    Semigroup.Last Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode

    #if !MIN_VERSION_base(4,16,0)
    -- | @since 0.2.0.0
    instance Serialise a => Serialise (Semigroup.Option a) where
      encode = encode . Semigroup.getOption
      decode = fmap Semigroup.Option decode
    #endif

    instance Serialise a => Serialise (Semigroup.WrappedMonoid a) where
      encode :: WrappedMonoid a -> Encoding
    encode = a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode (a -> Encoding)
    -> (WrappedMonoid a -> a) -> WrappedMonoid a -> Encoding
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . WrappedMonoid a -> a
    forall m. WrappedMonoid m -> m
    Semigroup.unwrapMonoid
      decode :: forall s. Decoder s (WrappedMonoid a)
    decode = (a -> WrappedMonoid a)
    -> Decoder s a -> Decoder s (WrappedMonoid a)
    forall a b. (a -> b) -> Decoder s a -> Decoder s b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> WrappedMonoid a
    forall m. m -> WrappedMonoid m
    Semigroup.WrapMonoid Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
    #endif

    --------------------------------------------------------------------------------
    -- Foreign types

    -- | @since 0.2.0.0
    instance Serialise CChar where
        encode :: CChar -> Encoding
    encode (CChar Int8
    x) = Int8 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Int8
    x
        decode :: forall s. Decoder s CChar
    decode = Int8 -> CChar
    CChar (Int8 -> CChar) -> Decoder s Int8 -> Decoder s CChar
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Int8
    forall s. Decoder s Int8
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CSChar where
        encode :: CSChar -> Encoding
    encode (CSChar Int8
    x) = Int8 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Int8
    x
        decode :: forall s. Decoder s CSChar
    decode = Int8 -> CSChar
    CSChar (Int8 -> CSChar) -> Decoder s Int8 -> Decoder s CSChar
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Int8
    forall s. Decoder s Int8
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CUChar where
        encode :: CUChar -> Encoding
    encode (CUChar Word8
    x) = Word8 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Word8
    x
        decode :: forall s. Decoder s CUChar
    decode = Word8 -> CUChar
    CUChar (Word8 -> CUChar) -> Decoder s Word8 -> Decoder s CUChar
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Word8
    forall s. Decoder s Word8
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CShort where
        encode :: CShort -> Encoding
    encode (CShort Int16
    x) = Int16 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Int16
    x
        decode :: forall s. Decoder s CShort
    decode = Int16 -> CShort
    CShort (Int16 -> CShort) -> Decoder s Int16 -> Decoder s CShort
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Int16
    forall s. Decoder s Int16
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CUShort where
        encode :: CUShort -> Encoding
    encode (CUShort Word16
    x) = Word16 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Word16
    x
        decode :: forall s. Decoder s CUShort
    decode = Word16 -> CUShort
    CUShort (Word16 -> CUShort) -> Decoder s Word16 -> Decoder s CUShort
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Word16
    forall s. Decoder s Word16
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CInt where
        encode :: CInt -> Encoding
    encode (CInt Int32
    x) = Int32 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Int32
    x
        decode :: forall s. Decoder s CInt
    decode = Int32 -> CInt
    CInt (Int32 -> CInt) -> Decoder s Int32 -> Decoder s CInt
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Int32
    forall s. Decoder s Int32
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CUInt where
        encode :: CUInt -> Encoding
    encode (CUInt Word32
    x) = Word32 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Word32
    x
        decode :: forall s. Decoder s CUInt
    decode = Word32 -> CUInt
    CUInt (Word32 -> CUInt) -> Decoder s Word32 -> Decoder s CUInt
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Word32
    forall s. Decoder s Word32
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CLong where
        encode :: CLong -> Encoding
    encode (CLong Int64
    x) = Int64 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Int64
    x
        decode :: forall s. Decoder s CLong
    decode = Int64 -> CLong
    CLong (Int64 -> CLong) -> Decoder s Int64 -> Decoder s CLong
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Int64
    forall s. Decoder s Int64
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CULong where
        encode :: CULong -> Encoding
    encode (CULong Word64
    x) = Word64 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Word64
    x
        decode :: forall s. Decoder s CULong
    decode = Word64 -> CULong
    CULong (Word64 -> CULong) -> Decoder s Word64 -> Decoder s CULong
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Word64
    forall s. Decoder s Word64
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CPtrdiff where
        encode :: CPtrdiff -> Encoding
    encode (CPtrdiff Int64
    x) = Int64 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Int64
    x
        decode :: forall s. Decoder s CPtrdiff
    decode = Int64 -> CPtrdiff
    CPtrdiff (Int64 -> CPtrdiff) -> Decoder s Int64 -> Decoder s CPtrdiff
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Int64
    forall s. Decoder s Int64
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CSize where
        encode :: CSize -> Encoding
    encode (CSize Word64
    x) = Word64 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Word64
    x
        decode :: forall s. Decoder s CSize
    decode = Word64 -> CSize
    CSize (Word64 -> CSize) -> Decoder s Word64 -> Decoder s CSize
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Word64
    forall s. Decoder s Word64
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CWchar where
        encode :: CWchar -> Encoding
    encode (CWchar Int32
    x) = Int32 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Int32
    x
        decode :: forall s. Decoder s CWchar
    decode = Int32 -> CWchar
    CWchar (Int32 -> CWchar) -> Decoder s Int32 -> Decoder s CWchar
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Int32
    forall s. Decoder s Int32
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CSigAtomic where
        encode :: CSigAtomic -> Encoding
    encode (CSigAtomic Int32
    x) = Int32 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Int32
    x
        decode :: forall s. Decoder s CSigAtomic
    decode = Int32 -> CSigAtomic
    CSigAtomic (Int32 -> CSigAtomic) -> Decoder s Int32 -> Decoder s CSigAtomic
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Int32
    forall s. Decoder s Int32
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CLLong where
        encode :: CLLong -> Encoding
    encode (CLLong Int64
    x) = Int64 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Int64
    x
        decode :: forall s. Decoder s CLLong
    decode = Int64 -> CLLong
    CLLong (Int64 -> CLLong) -> Decoder s Int64 -> Decoder s CLLong
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Int64
    forall s. Decoder s Int64
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CULLong where
        encode :: CULLong -> Encoding
    encode (CULLong Word64
    x) = Word64 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Word64
    x
        decode :: forall s. Decoder s CULLong
    decode = Word64 -> CULLong
    CULLong (Word64 -> CULLong) -> Decoder s Word64 -> Decoder s CULLong
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Word64
    forall s. Decoder s Word64
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CIntPtr where
        encode :: CIntPtr -> Encoding
    encode (CIntPtr Int64
    x) = Int64 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Int64
    x
        decode :: forall s. Decoder s CIntPtr
    decode = Int64 -> CIntPtr
    CIntPtr (Int64 -> CIntPtr) -> Decoder s Int64 -> Decoder s CIntPtr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Int64
    forall s. Decoder s Int64
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CUIntPtr where
        encode :: CUIntPtr -> Encoding
    encode (CUIntPtr Word64
    x) = Word64 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Word64
    x
        decode :: forall s. Decoder s CUIntPtr
    decode = Word64 -> CUIntPtr
    CUIntPtr (Word64 -> CUIntPtr) -> Decoder s Word64 -> Decoder s CUIntPtr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Word64
    forall s. Decoder s Word64
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CIntMax where
        encode :: CIntMax -> Encoding
    encode (CIntMax Int64
    x) = Int64 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Int64
    x
        decode :: forall s. Decoder s CIntMax
    decode = Int64 -> CIntMax
    CIntMax (Int64 -> CIntMax) -> Decoder s Int64 -> Decoder s CIntMax
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Int64
    forall s. Decoder s Int64
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CUIntMax where
        encode :: CUIntMax -> Encoding
    encode (CUIntMax Word64
    x) = Word64 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Word64
    x
        decode :: forall s. Decoder s CUIntMax
    decode = Word64 -> CUIntMax
    CUIntMax (Word64 -> CUIntMax) -> Decoder s Word64 -> Decoder s CUIntMax
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Word64
    forall s. Decoder s Word64
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CClock where
        encode :: CClock -> Encoding
    encode (CClock Int64
    x) = Int64 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Int64
    x
        decode :: forall s. Decoder s CClock
    decode = Int64 -> CClock
    CClock (Int64 -> CClock) -> Decoder s Int64 -> Decoder s CClock
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Int64
    forall s. Decoder s Int64
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CTime where
        encode :: CTime -> Encoding
    encode (CTime Int64
    x) = Int64 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Int64
    x
        decode :: forall s. Decoder s CTime
    decode = Int64 -> CTime
    CTime (Int64 -> CTime) -> Decoder s Int64 -> Decoder s CTime
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Int64
    forall s. Decoder s Int64
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CUSeconds where
        encode :: CUSeconds -> Encoding
    encode (CUSeconds Word32
    x) = Word32 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Word32
    x
        decode :: forall s. Decoder s CUSeconds
    decode = Word32 -> CUSeconds
    CUSeconds (Word32 -> CUSeconds) -> Decoder s Word32 -> Decoder s CUSeconds
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Word32
    forall s. Decoder s Word32
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CSUSeconds where
        encode :: CSUSeconds -> Encoding
    encode (CSUSeconds Int64
    x) = Int64 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Int64
    x
        decode :: forall s. Decoder s CSUSeconds
    decode = Int64 -> CSUSeconds
    CSUSeconds (Int64 -> CSUSeconds) -> Decoder s Int64 -> Decoder s CSUSeconds
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Int64
    forall s. Decoder s Int64
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CFloat where
        encode :: CFloat -> Encoding
    encode (CFloat Float
    x) = Float -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Float
    x
        decode :: forall s. Decoder s CFloat
    decode = Float -> CFloat
    CFloat (Float -> CFloat) -> Decoder s Float -> Decoder s CFloat
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Float
    forall s. Decoder s Float
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance Serialise CDouble where
        encode :: CDouble -> Encoding
    encode (CDouble Double
    x) = Double -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Double
    x
        decode :: forall s. Decoder s CDouble
    decode = Double -> CDouble
    CDouble (Double -> CDouble) -> Decoder s Double -> Decoder s CDouble
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Double
    forall s. Decoder s Double
    forall a s. Serialise a => Decoder s a
    decode

    --------------------------------------------------------------------------------
    -- Structural instances

    -- | @since 0.2.0.0
    instance (Serialise a, Serialise b) => Serialise (a,b) where
        encode :: (a, b) -> Encoding
    encode (a
    a,b
    b) = Word -> Encoding
    encodeListLen Word
    2
                    Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    a
                    Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> b -> Encoding
    forall a. Serialise a => a -> Encoding
    encode b
    b
        decode :: forall s. Decoder s (a, b)
    decode = do Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    2
                    !x <- Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
                    !y <- decode
                    return (x, y)

    -- | @since 0.2.0.0
    instance (Serialise a, Serialise b, Serialise c) => Serialise (a,b,c) where
        encode :: (a, b, c) -> Encoding
    encode (a
    a,b
    b,c
    c) = Word -> Encoding
    encodeListLen Word
    3
                      Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    a
                      Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> b -> Encoding
    forall a. Serialise a => a -> Encoding
    encode b
    b
                      Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> c -> Encoding
    forall a. Serialise a => a -> Encoding
    encode c
    c

        decode :: forall s. Decoder s (a, b, c)
    decode = do Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    3
                    !x <- Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
                    !y <- decode
                    !z <- decode
                    return (x, y, z)

    -- | @since 0.2.0.0
    instance (Serialise a, Serialise b, Serialise c, Serialise d
             ) => Serialise (a,b,c,d) where
        encode :: (a, b, c, d) -> Encoding
    encode (a
    a,b
    b,c
    c,d
    d) = Word -> Encoding
    encodeListLen Word
    4
                        Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    a
                        Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> b -> Encoding
    forall a. Serialise a => a -> Encoding
    encode b
    b
                        Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> c -> Encoding
    forall a. Serialise a => a -> Encoding
    encode c
    c
                        Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> d -> Encoding
    forall a. Serialise a => a -> Encoding
    encode d
    d

        decode :: forall s. Decoder s (a, b, c, d)
    decode = do Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    4
                    !a <- Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
                    !b <- decode
                    !c <- decode
                    !d <- decode
                    return (a, b, c, d)

    -- | @since 0.2.0.0
    instance (Serialise a, Serialise b, Serialise c, Serialise d, Serialise e
             ) => Serialise (a,b,c,d,e) where
        encode :: (a, b, c, d, e) -> Encoding
    encode (a
    a,b
    b,c
    c,d
    d,e
    e) = Word -> Encoding
    encodeListLen Word
    5
                          Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    a
                          Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> b -> Encoding
    forall a. Serialise a => a -> Encoding
    encode b
    b
                          Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> c -> Encoding
    forall a. Serialise a => a -> Encoding
    encode c
    c
                          Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> d -> Encoding
    forall a. Serialise a => a -> Encoding
    encode d
    d
                          Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> e -> Encoding
    forall a. Serialise a => a -> Encoding
    encode e
    e

        decode :: forall s. Decoder s (a, b, c, d, e)
    decode = do Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    5
                    !a <- Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
                    !b <- decode
                    !c <- decode
                    !d <- decode
                    !e <- decode
                    return (a, b, c, d, e)

    -- | @since 0.2.0.0
    instance ( Serialise a, Serialise b, Serialise c, Serialise d, Serialise e
             , Serialise f
             ) => Serialise (a,b,c,d,e,f) where
        encode :: (a, b, c, d, e, f) -> Encoding
    encode (a
    a,b
    b,c
    c,d
    d,e
    e,f
    f) = Word -> Encoding
    encodeListLen Word
    6
                            Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    a
                            Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> b -> Encoding
    forall a. Serialise a => a -> Encoding
    encode b
    b
                            Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> c -> Encoding
    forall a. Serialise a => a -> Encoding
    encode c
    c
                            Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> d -> Encoding
    forall a. Serialise a => a -> Encoding
    encode d
    d
                            Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> e -> Encoding
    forall a. Serialise a => a -> Encoding
    encode e
    e
                            Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> f -> Encoding
    forall a. Serialise a => a -> Encoding
    encode f
    f

        decode :: forall s. Decoder s (a, b, c, d, e, f)
    decode = do Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    6
                    !a <- Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
                    !b <- decode
                    !c <- decode
                    !d <- decode
                    !e <- decode
                    !f <- decode
                    return (a, b, c, d, e, f)

    -- | @since 0.2.0.0
    instance ( Serialise a, Serialise b, Serialise c, Serialise d, Serialise e
             , Serialise f, Serialise g
             ) => Serialise (a,b,c,d,e,f,g) where
        encode :: (a, b, c, d, e, f, g) -> Encoding
    encode (a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g) = Word -> Encoding
    encodeListLen Word
    7
                              Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    a
                              Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> b -> Encoding
    forall a. Serialise a => a -> Encoding
    encode b
    b
                              Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> c -> Encoding
    forall a. Serialise a => a -> Encoding
    encode c
    c
                              Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> d -> Encoding
    forall a. Serialise a => a -> Encoding
    encode d
    d
                              Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> e -> Encoding
    forall a. Serialise a => a -> Encoding
    encode e
    e
                              Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> f -> Encoding
    forall a. Serialise a => a -> Encoding
    encode f
    f
                              Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> g -> Encoding
    forall a. Serialise a => a -> Encoding
    encode g
    g

        decode :: forall s. Decoder s (a, b, c, d, e, f, g)
    decode = do Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    7
                    !a <- Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
                    !b <- decode
                    !c <- decode
                    !d <- decode
                    !e <- decode
                    !f <- decode
                    !g <- decode
                    return (a, b, c, d, e, f, g)

    -- | @since 0.2.0.0
    instance ( Serialise a, Serialise b, Serialise c, Serialise d, Serialise e
             , Serialise f, Serialise g, Serialise h
             ) => Serialise (a,b,c,d,e,f,g,h) where
        encode :: (a, b, c, d, e, f, g, h) -> Encoding
    encode (a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h) = Word -> Encoding
    encodeListLen Word
    8
                                Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    a
                                Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> b -> Encoding
    forall a. Serialise a => a -> Encoding
    encode b
    b
                                Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> c -> Encoding
    forall a. Serialise a => a -> Encoding
    encode c
    c
                                Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> d -> Encoding
    forall a. Serialise a => a -> Encoding
    encode d
    d
                                Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> e -> Encoding
    forall a. Serialise a => a -> Encoding
    encode e
    e
                                Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> f -> Encoding
    forall a. Serialise a => a -> Encoding
    encode f
    f
                                Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> g -> Encoding
    forall a. Serialise a => a -> Encoding
    encode g
    g
                                Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> h -> Encoding
    forall a. Serialise a => a -> Encoding
    encode h
    h

        decode :: forall s. Decoder s (a, b, c, d, e, f, g, h)
    decode = do Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    8
                    !a <- Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
                    !b <- decode
                    !c <- decode
                    !d <- decode
                    !e <- decode
                    !f <- decode
                    !g <- decode
                    !h <- decode
                    return (a, b, c, d, e, f, g, h)

    -- | @since 0.2.0.0
    instance ( Serialise a, Serialise b, Serialise c, Serialise d, Serialise e
             , Serialise f, Serialise g, Serialise h, Serialise i
             ) => Serialise (a,b,c,d,e,f,g,h,i) where
        encode :: (a, b, c, d, e, f, g, h, i) -> Encoding
    encode (a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h,i
    i) = Word -> Encoding
    encodeListLen Word
    9
                                  Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    a
                                  Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> b -> Encoding
    forall a. Serialise a => a -> Encoding
    encode b
    b
                                  Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> c -> Encoding
    forall a. Serialise a => a -> Encoding
    encode c
    c
                                  Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> d -> Encoding
    forall a. Serialise a => a -> Encoding
    encode d
    d
                                  Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> e -> Encoding
    forall a. Serialise a => a -> Encoding
    encode e
    e
                                  Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> f -> Encoding
    forall a. Serialise a => a -> Encoding
    encode f
    f
                                  Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> g -> Encoding
    forall a. Serialise a => a -> Encoding
    encode g
    g
                                  Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> h -> Encoding
    forall a. Serialise a => a -> Encoding
    encode h
    h
                                  Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> i -> Encoding
    forall a. Serialise a => a -> Encoding
    encode i
    i

        decode :: forall s. Decoder s (a, b, c, d, e, f, g, h, i)
    decode = do Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    9
                    !a <- Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
                    !b <- decode
                    !c <- decode
                    !d <- decode
                    !e <- decode
                    !f <- decode
                    !g <- decode
                    !h <- decode
                    !i <- decode
                    return (a, b, c, d, e, f, g, h, i)

    -- | @since 0.2.0.0
    instance Serialise a => Serialise (Maybe a) where
        encode :: Maybe a -> Encoding
    encode Maybe a
    Nothing  = Word -> Encoding
    encodeListLen Word
    0
        encode (Just a
    x) = Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    x

        decode :: forall s. Decoder s (Maybe a)
    decode = do n <- Decoder s Int
    forall s. Decoder s Int
    decodeListLen
                    case n of
                      Int
    0 -> Maybe a -> Decoder s (Maybe a)
    forall a. a -> Decoder s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe a
    forall a. Maybe a
    Nothing
                      Int
    1 -> do !x <- Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
                              return (Just x)
                      Int
    _ -> String -> Decoder s (Maybe a)
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "unknown tag"

    -- | @since 0.2.0.0
    instance (Serialise a, Serialise b) => Serialise (Either a b) where
        encode :: Either a b -> Encoding
    encode (Left  a
    x) = Word -> Encoding
    encodeListLen Word
    2 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    0 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    x
        encode (Right b
    x) = Word -> Encoding
    encodeListLen Word
    2 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> b -> Encoding
    forall a. Serialise a => a -> Encoding
    encode b
    x

        decode :: forall s. Decoder s (Either a b)
    decode = do Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    2
                    t <- Decoder s Word
    forall s. Decoder s Word
    decodeWord
                    case t of
                      Word
    0 -> do !x <- Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
                              return (Left x)
                      Word
    1 -> do !x <- Decoder s b
    forall s. Decoder s b
    forall a s. Serialise a => Decoder s a
    decode
                              return (Right x)
                      Word
    _ -> String -> Decoder s (Either a b)
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "unknown tag"

    -- | @since 0.2.4.0
    instance (Serialise a, Serialise b) => Serialise (These.These a b) where
        encode :: These a b -> Encoding
    encode (These.This a
    x) = Word -> Encoding
    encodeListLen Word
    2 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    0 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    x
        encode (These.That b
    x) = Word -> Encoding
    encodeListLen Word
    2 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> b -> Encoding
    forall a. Serialise a => a -> Encoding
    encode b
    x
        encode (These.These a
    x b
    y) = Word -> Encoding
    encodeListLen Word
    3 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    2 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    x Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> b -> Encoding
    forall a. Serialise a => a -> Encoding
    encode b
    y

        decode :: forall s. Decoder s (These a b)
    decode = do n <- Decoder s Int
    forall s. Decoder s Int
    decodeListLen
                    t <- decodeWord
                    case (t, n) of
                      (Word
    0, Int
    2) -> do !x <- Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
                                   return (These.This x)
                      (Word
    1, Int
    2) -> do !x <- Decoder s b
    forall s. Decoder s b
    forall a s. Serialise a => Decoder s a
    decode
                                   return (These.That x)
                      (Word
    2, Int
    3) -> do !x <- Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
                                   !y <- decode
                                   return (These.These x y)
                      (Word, Int)
    _ -> String -> Decoder s (These a b)
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "unknown tag"

    -- | @since 0.2.4.0
    instance (Serialise a, Serialise b) => Serialise (Strict.Pair a b) where
        encode :: Pair a b -> Encoding
    encode = (a, b) -> Encoding
    forall a. Serialise a => a -> Encoding
    encode ((a, b) -> Encoding)
    -> (Pair a b -> (a, b)) -> Pair a b -> Encoding
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Pair a b -> (a, b)
    forall lazy strict. Strict lazy strict => strict -> lazy
    Strict.toLazy
        decode :: forall s. Decoder s (Pair a b)
    decode = (a, b) -> Pair a b
    forall lazy strict. Strict lazy strict => lazy -> strict
    Strict.toStrict ((a, b) -> Pair a b) -> Decoder s (a, b) -> Decoder s (Pair a b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s (a, b)
    forall s. Decoder s (a, b)
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.4.0
    instance Serialise a => Serialise (Strict.Maybe a) where
        encode :: Maybe a -> Encoding
    encode = Maybe a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode (Maybe a -> Encoding)
    -> (Maybe a -> Maybe a) -> Maybe a -> Encoding
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Maybe a -> Maybe a
    forall lazy strict. Strict lazy strict => strict -> lazy
    Strict.toLazy
        decode :: forall s. Decoder s (Maybe a)
    decode = Maybe a -> Maybe a
    forall lazy strict. Strict lazy strict => lazy -> strict
    Strict.toStrict (Maybe a -> Maybe a) -> Decoder s (Maybe a) -> Decoder s (Maybe a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s (Maybe a)
    forall s. Decoder s (Maybe a)
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.4.0
    instance (Serialise a, Serialise b) => Serialise (Strict.Either a b) where
        encode :: Either a b -> Encoding
    encode = Either a b -> Encoding
    forall a. Serialise a => a -> Encoding
    encode (Either a b -> Encoding)
    -> (Either a b -> Either a b) -> Either a b -> Encoding
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Either a b -> Either a b
    forall lazy strict. Strict lazy strict => strict -> lazy
    Strict.toLazy
        decode :: forall s. Decoder s (Either a b)
    decode = Either a b -> Either a b
    forall lazy strict. Strict lazy strict => lazy -> strict
    Strict.toStrict (Either a b -> Either a b)
    -> Decoder s (Either a b) -> Decoder s (Either a b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s (Either a b)
    forall s. Decoder s (Either a b)
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.4.0
    instance (Serialise a, Serialise b) => Serialise (Strict.These a b) where
        encode :: These a b -> Encoding
    encode = These a b -> Encoding
    forall a. Serialise a => a -> Encoding
    encode (These a b -> Encoding)
    -> (These a b -> These a b) -> These a b -> Encoding
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . These a b -> These a b
    forall lazy strict. Strict lazy strict => strict -> lazy
    Strict.toLazy
        decode :: forall s. Decoder s (These a b)
    decode = These a b -> These a b
    forall lazy strict. Strict lazy strict => lazy -> strict
    Strict.toStrict (These a b -> These a b)
    -> Decoder s (These a b) -> Decoder s (These a b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s (These a b)
    forall s. Decoder s (These a b)
    forall a s. Serialise a => Decoder s a
    decode

    --------------------------------------------------------------------------------
    -- Container instances

    -- | @since 0.2.0.0
    instance Serialise a => Serialise (Tree.Tree a) where
      encode :: Tree a -> Encoding
    encode (Tree.Node a
    r [Tree a]
    sub) = Word -> Encoding
    encodeListLen Word
    2 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    r Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> [Tree a] -> Encoding
    forall a. Serialise a => a -> Encoding
    encode [Tree a]
    sub
      decode :: forall s. Decoder s (Tree a)
    decode = Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    2 Decoder s () -> Decoder s (Tree a) -> Decoder s (Tree a)
    forall a b. Decoder s a -> Decoder s b -> Decoder s b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> (a -> [Tree a] -> Tree a
    forall a. a -> [Tree a] -> Tree a
    Tree.Node (a -> [Tree a] -> Tree a)
    -> Decoder s a -> Decoder s ([Tree a] -> Tree a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode Decoder s ([Tree a] -> Tree a)
    -> Decoder s [Tree a] -> Decoder s (Tree a)
    forall a b. Decoder s (a -> b) -> Decoder s a -> Decoder s b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Decoder s [Tree a]
    forall s. Decoder s [Tree a]
    forall a s. Serialise a => Decoder s a
    decode)

    -- | Patch functions together to obtain an 'Encoding' for a container.
    encodeContainerSkel :: (Word -> Encoding) -- ^ encoder of the length
                        -> (container -> Int) -- ^ length
                        -> (accumFunc -> Encoding -> container -> Encoding) -- ^ foldr
                        -> accumFunc
                        -> container
                        -> Encoding
    encodeContainerSkel :: forall container accumFunc.
    (Word -> Encoding)
    -> (container -> Int)
    -> (accumFunc -> Encoding -> container -> Encoding)
    -> accumFunc
    -> container
    -> Encoding
    encodeContainerSkel Word -> Encoding
    encodeLen container -> Int
    size accumFunc -> Encoding -> container -> Encoding
    foldr accumFunc
    f  container
    c =
        Word -> Encoding
    encodeLen (Int -> Word
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (container -> Int
    size container
    c)) Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> accumFunc -> Encoding -> container -> Encoding
    foldr accumFunc
    f Encoding
    forall a. Monoid a => a
    mempty container
    c
    {-# INLINE encodeContainerSkel #-}

    decodeContainerSkelWithReplicate
      :: (Serialise a)
      => Decoder s Int
         -- ^ How to get the size of the container
      -> (Int -> Decoder s a -> Decoder s container)
         -- ^ replicateM for the container
      -> ([container] -> container)
         -- ^ concat for the container
      -> Decoder s container
    decodeContainerSkelWithReplicate :: forall a s container.
    Serialise a =>
    Decoder s Int
    -> (Int -> Decoder s a -> Decoder s container)
    -> ([container] -> container)
    -> Decoder s container
    decodeContainerSkelWithReplicate Decoder s Int
    decodeLen Int -> Decoder s a -> Decoder s container
    replicateFun [container] -> container
    fromList = do
        -- Look at how much data we have at the moment and use it as the limit for
        -- the size of a single call to replicateFun. We don't want to use
        -- replicateFun directly on the result of decodeLen since this might lead to
        -- DOS attack (attacker providing a huge value for length). So if it's above
        -- our limit, we'll do manual chunking and then combine the containers into
        -- one.
        size <- Decoder s Int
    decodeLen
        limit <- peekAvailable
        if size <= limit
           then replicateFun size decode
           else do
               -- Take the max of limit and a fixed chunk size (note: limit can be
               -- 0). This basically means that the attacker can make us allocate a
               -- container of size 128 even though there's no actual input.
               let chunkSize = Int -> Int -> Int
    forall a. Ord a => a -> a -> a
    max Int
    limit Int
    128
                   (d, m) = size `divMod` chunkSize
                   buildOne Int
    s = Int -> Decoder s a -> Decoder s container
    replicateFun Int
    s Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode
               containers <- sequence $ buildOne m : replicate d (buildOne chunkSize)
               return $! fromList containers
    {-# INLINE decodeContainerSkelWithReplicate #-}

    -- | @since 0.2.0.0
    instance (Serialise a) => Serialise (Sequence.Seq a) where
      encode :: Seq a -> Encoding
    encode = (Word -> Encoding)
    -> (Seq a -> Int)
    -> ((a -> Encoding -> Encoding) -> Encoding -> Seq a -> Encoding)
    -> (a -> Encoding -> Encoding)
    -> Seq a
    -> Encoding
    forall container accumFunc.
    (Word -> Encoding)
    -> (container -> Int)
    -> (accumFunc -> Encoding -> container -> Encoding)
    -> accumFunc
    -> container
    -> Encoding
    encodeContainerSkel
                 Word -> Encoding
    encodeListLen
                 Seq a -> Int
    forall a. Seq a -> Int
    Sequence.length
                 (a -> Encoding -> Encoding) -> Encoding -> Seq a -> Encoding
    forall a b. (a -> b -> b) -> b -> Seq a -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    Foldable.foldr
                 (\a
    a Encoding
    b -> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    a Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Encoding
    b)
      decode :: forall s. Decoder s (Seq a)
    decode = Decoder s Int
    -> (Int -> Decoder s a -> Decoder s (Seq a))
    -> ([Seq a] -> Seq a)
    -> Decoder s (Seq a)
    forall a s container.
    Serialise a =>
    Decoder s Int
    -> (Int -> Decoder s a -> Decoder s container)
    -> ([container] -> container)
    -> Decoder s container
    decodeContainerSkelWithReplicate
                 Decoder s Int
    forall s. Decoder s Int
    decodeListLen
                 Int -> Decoder s a -> Decoder s (Seq a)
    forall (m :: * -> *) a. Applicative m => Int -> m a -> m (Seq a)
    Sequence.replicateM
                 [Seq a] -> Seq a
    forall a. Monoid a => [a] -> a
    mconcat

    -- | Generic encoder for vectors. Its intended use is to allow easy
    -- definition of 'Serialise' instances for custom vector
    --
    -- @since 0.2.0.0
    encodeVector :: (Serialise a, Vector.Generic.Vector v a)
                 => v a -> Encoding
    encodeVector :: forall a (v :: * -> *).
    (Serialise a, Vector v a) =>
    v a -> Encoding
    encodeVector = (Word -> Encoding)
    -> (v a -> Int)
    -> ((a -> Encoding -> Encoding) -> Encoding -> v a -> Encoding)
    -> (a -> Encoding -> Encoding)
    -> v a
    -> Encoding
    forall container accumFunc.
    (Word -> Encoding)
    -> (container -> Int)
    -> (accumFunc -> Encoding -> container -> Encoding)
    -> accumFunc
    -> container
    -> Encoding
    encodeContainerSkel
        Word -> Encoding
    encodeListLen
        v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    Vector.Generic.length
        (a -> Encoding -> Encoding) -> Encoding -> v a -> Encoding
    forall (v :: * -> *) a b.
    Vector v a =>
    (a -> b -> b) -> b -> v a -> b
    Vector.Generic.foldr
        (\a
    a Encoding
    b -> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    a Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Encoding
    b)
    {-# INLINE encodeVector #-}

    -- | Generic decoder for vectors. Its intended use is to allow easy
    -- definition of 'Serialise' instances for custom vector
    --
    -- @since 0.2.0.0
    decodeVector :: (Serialise a, Vector.Generic.Vector v a)
                 => Decoder s (v a)
    decodeVector :: forall a (v :: * -> *) s.
    (Serialise a, Vector v a) =>
    Decoder s (v a)
    decodeVector = Decoder s Int
    -> (Int -> Decoder s a -> Decoder s (v a))
    -> ([v a] -> v a)
    -> Decoder s (v a)
    forall a s container.
    Serialise a =>
    Decoder s Int
    -> (Int -> Decoder s a -> Decoder s container)
    -> ([container] -> container)
    -> Decoder s container
    decodeContainerSkelWithReplicate
        Decoder s Int
    forall s. Decoder s Int
    decodeListLen
        Int -> Decoder s a -> Decoder s (v a)
    forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a) =>
    Int -> m a -> m (v a)
    Vector.Generic.replicateM
        [v a] -> v a
    forall (v :: * -> *) a. Vector v a => [v a] -> v a
    Vector.Generic.concat
    {-# INLINE decodeVector #-}

    -- | @since 0.2.0.0
    instance (Serialise a) => Serialise (Vector.Vector a) where
      encode :: Vector a -> Encoding
    encode = Vector a -> Encoding
    forall a (v :: * -> *).
    (Serialise a, Vector v a) =>
    v a -> Encoding
    encodeVector
      {-# INLINE encode #-}
      decode :: forall s. Decoder s (Vector a)
    decode = Decoder s (Vector a)
    forall a (v :: * -> *) s.
    (Serialise a, Vector v a) =>
    Decoder s (v a)
    decodeVector
      {-# INLINE decode #-}

    -- | @since 0.2.0.0
    instance (Serialise a, Vector.Unboxed.Unbox a) =>
             Serialise (Vector.Unboxed.Vector a) where
      encode :: Vector a -> Encoding
    encode = Vector a -> Encoding
    forall a (v :: * -> *).
    (Serialise a, Vector v a) =>
    v a -> Encoding
    encodeVector
      {-# INLINE encode #-}
      decode :: forall s. Decoder s (Vector a)
    decode = Decoder s (Vector a)
    forall a (v :: * -> *) s.
    (Serialise a, Vector v a) =>
    Decoder s (v a)
    decodeVector
      {-# INLINE decode #-}

    -- | @since 0.2.0.0
    instance (Serialise a, Vector.Storable.Storable a) => Serialise (Vector.Storable.Vector a) where
      encode :: Vector a -> Encoding
    encode = Vector a -> Encoding
    forall a (v :: * -> *).
    (Serialise a, Vector v a) =>
    v a -> Encoding
    encodeVector
      {-# INLINE encode #-}
      decode :: forall s. Decoder s (Vector a)
    decode = Decoder s (Vector a)
    forall a (v :: * -> *) s.
    (Serialise a, Vector v a) =>
    Decoder s (v a)
    decodeVector
      {-# INLINE decode #-}

    -- | @since 0.2.0.0
    instance (Serialise a, Vector.Primitive.Prim a) => Serialise (Vector.Primitive.Vector a) where
      encode :: Vector a -> Encoding
    encode = Vector a -> Encoding
    forall a (v :: * -> *).
    (Serialise a, Vector v a) =>
    v a -> Encoding
    encodeVector
      {-# INLINE encode #-}
      decode :: forall s. Decoder s (Vector a)
    decode = Decoder s (Vector a)
    forall a (v :: * -> *) s.
    (Serialise a, Vector v a) =>
    Decoder s (v a)
    decodeVector
      {-# INLINE decode #-}

    encodeSetSkel :: Serialise a
                  => (s -> Int)
                  -> ((a -> Encoding -> Encoding) -> Encoding -> s -> Encoding)
                  -> s
                  -> Encoding
    encodeSetSkel :: forall a s.
    Serialise a =>
    (s -> Int)
    -> ((a -> Encoding -> Encoding) -> Encoding -> s -> Encoding)
    -> s
    -> Encoding
    encodeSetSkel s -> Int
    size (a -> Encoding -> Encoding) -> Encoding -> s -> Encoding
    foldr =
        (Word -> Encoding)
    -> (s -> Int)
    -> ((a -> Encoding -> Encoding) -> Encoding -> s -> Encoding)
    -> (a -> Encoding -> Encoding)
    -> s
    -> Encoding
    forall container accumFunc.
    (Word -> Encoding)
    -> (container -> Int)
    -> (accumFunc -> Encoding -> container -> Encoding)
    -> accumFunc
    -> container
    -> Encoding
    encodeContainerSkel Word -> Encoding
    encodeListLen s -> Int
    size (a -> Encoding -> Encoding) -> Encoding -> s -> Encoding
    foldr (\a
    a Encoding
    b -> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    a Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Encoding
    b)
    {-# INLINE encodeSetSkel #-}

    decodeSetSkel :: Serialise a
                  => ([a] -> c) -> Decoder s c
    decodeSetSkel :: forall a c s. Serialise a => ([a] -> c) -> Decoder s c
    decodeSetSkel [a] -> c
    fromList = do
      n <- Decoder s Int
    forall s. Decoder s Int
    decodeListLen
      fmap fromList (replicateM n decode)
    {-# INLINE decodeSetSkel #-}

    -- | @since 0.2.0.0
    instance (Ord a, Serialise a) => Serialise (Set.Set a) where
      encode :: Set a -> Encoding
    encode = (Set a -> Int)
    -> ((a -> Encoding -> Encoding) -> Encoding -> Set a -> Encoding)
    -> Set a
    -> Encoding
    forall a s.
    Serialise a =>
    (s -> Int)
    -> ((a -> Encoding -> Encoding) -> Encoding -> s -> Encoding)
    -> s
    -> Encoding
    encodeSetSkel Set a -> Int
    forall a. Set a -> Int
    Set.size (a -> Encoding -> Encoding) -> Encoding -> Set a -> Encoding
    forall a b. (a -> b -> b) -> b -> Set a -> b
    Set.foldr
      decode :: forall s. Decoder s (Set a)
    decode = ([a] -> Set a) -> Decoder s (Set a)
    forall a c s. Serialise a => ([a] -> c) -> Decoder s c
    decodeSetSkel [a] -> Set a
    forall a. Ord a => [a] -> Set a
    Set.fromList

    -- | @since 0.2.0.0
    instance Serialise IntSet.IntSet where
      encode :: IntSet -> Encoding
    encode = (IntSet -> Int)
    -> ((Int -> Encoding -> Encoding)
        -> Encoding -> IntSet -> Encoding)
    -> IntSet
    -> Encoding
    forall a s.
    Serialise a =>
    (s -> Int)
    -> ((a -> Encoding -> Encoding) -> Encoding -> s -> Encoding)
    -> s
    -> Encoding
    encodeSetSkel IntSet -> Int
    IntSet.size (Int -> Encoding -> Encoding) -> Encoding -> IntSet -> Encoding
    forall b. (Int -> b -> b) -> b -> IntSet -> b
    IntSet.foldr
      decode :: forall s. Decoder s IntSet
    decode = ([Int] -> IntSet) -> Decoder s IntSet
    forall a c s. Serialise a => ([a] -> c) -> Decoder s c
    decodeSetSkel [Int] -> IntSet
    IntSet.fromList

    -- | @since 0.2.0.0
    instance (Serialise a, Hashable a, Eq a) => Serialise (HashSet.HashSet a) where
      encode :: HashSet a -> Encoding
    encode = (HashSet a -> Int)
    -> ((a -> Encoding -> Encoding)
        -> Encoding -> HashSet a -> Encoding)
    -> HashSet a
    -> Encoding
    forall a s.
    Serialise a =>
    (s -> Int)
    -> ((a -> Encoding -> Encoding) -> Encoding -> s -> Encoding)
    -> s
    -> Encoding
    encodeSetSkel HashSet a -> Int
    forall a. HashSet a -> Int
    HashSet.size (a -> Encoding -> Encoding) -> Encoding -> HashSet a -> Encoding
    forall b a. (b -> a -> a) -> a -> HashSet b -> a
    HashSet.foldr
      decode :: forall s. Decoder s (HashSet a)
    decode = ([a] -> HashSet a) -> Decoder s (HashSet a)
    forall a c s. Serialise a => ([a] -> c) -> Decoder s c
    decodeSetSkel [a] -> HashSet a
    forall a. (Eq a, Hashable a) => [a] -> HashSet a
    HashSet.fromList

    -- | A helper function for encoding maps.
    encodeMapSkel :: (Serialise k, Serialise v)
                  => (m -> Int) -- ^ obtain the length
                  -> ((k -> v -> Encoding -> Encoding) -> Encoding -> m -> Encoding)
                  -> m
                  -> Encoding
    encodeMapSkel :: forall k v m.
    (Serialise k, Serialise v) =>
    (m -> Int)
    -> ((k -> v -> Encoding -> Encoding) -> Encoding -> m -> Encoding)
    -> m
    -> Encoding
    encodeMapSkel m -> Int
    size (k -> v -> Encoding -> Encoding) -> Encoding -> m -> Encoding
    foldrWithKey =
      (Word -> Encoding)
    -> (m -> Int)
    -> ((k -> v -> Encoding -> Encoding) -> Encoding -> m -> Encoding)
    -> (k -> v -> Encoding -> Encoding)
    -> m
    -> Encoding
    forall container accumFunc.
    (Word -> Encoding)
    -> (container -> Int)
    -> (accumFunc -> Encoding -> container -> Encoding)
    -> accumFunc
    -> container
    -> Encoding
    encodeContainerSkel
        Word -> Encoding
    encodeMapLen
        m -> Int
    size
        (k -> v -> Encoding -> Encoding) -> Encoding -> m -> Encoding
    foldrWithKey
        (\k
    k v
    v Encoding
    b -> k -> Encoding
    forall a. Serialise a => a -> Encoding
    encode k
    k Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> v -> Encoding
    forall a. Serialise a => a -> Encoding
    encode v
    v Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Encoding
    b)
    {-# INLINE encodeMapSkel #-}

    -- | A utility function to construct a 'Decoder' for maps.
    decodeMapSkel :: (Serialise k, Serialise v)
                  => ([(k,v)] -> m) -- ^ fromList
                  -> Decoder s m
    decodeMapSkel :: forall k v m s.
    (Serialise k, Serialise v) =>
    ([(k, v)] -> m) -> Decoder s m
    decodeMapSkel [(k, v)] -> m
    fromList = do
      n <- Decoder s Int
    forall s. Decoder s Int
    decodeMapLen
      let decodeEntry = do
            !k <- Decoder s k
    forall s. Decoder s k
    forall a s. Serialise a => Decoder s a
    decode
            !v <- decode
            return (k, v)
      fmap fromList (replicateM n decodeEntry)
    {-# INLINE decodeMapSkel #-}

    -- | @since 0.2.0.0
    instance (Ord k, Serialise k, Serialise v) => Serialise (Map.Map k v) where
      encode :: Map k v -> Encoding
    encode = (Map k v -> Int)
    -> ((k -> v -> Encoding -> Encoding)
        -> Encoding -> Map k v -> Encoding)
    -> Map k v
    -> Encoding
    forall k v m.
    (Serialise k, Serialise v) =>
    (m -> Int)
    -> ((k -> v -> Encoding -> Encoding) -> Encoding -> m -> Encoding)
    -> m
    -> Encoding
    encodeMapSkel Map k v -> Int
    forall k a. Map k a -> Int
    Map.size (k -> v -> Encoding -> Encoding) -> Encoding -> Map k v -> Encoding
    forall k a b. (k -> a -> b -> b) -> b -> Map k a -> b
    Map.foldrWithKey
      decode :: forall s. Decoder s (Map k v)
    decode = ([(k, v)] -> Map k v) -> Decoder s (Map k v)
    forall k v m s.
    (Serialise k, Serialise v) =>
    ([(k, v)] -> m) -> Decoder s m
    decodeMapSkel [(k, v)] -> Map k v
    forall k a. Ord k => [(k, a)] -> Map k a
    Map.fromList

    -- | @since 0.2.0.0
    instance (Serialise a) => Serialise (IntMap.IntMap a) where
      encode :: IntMap a -> Encoding
    encode = (IntMap a -> Int)
    -> ((Int -> a -> Encoding -> Encoding)
        -> Encoding -> IntMap a -> Encoding)
    -> IntMap a
    -> Encoding
    forall k v m.
    (Serialise k, Serialise v) =>
    (m -> Int)
    -> ((k -> v -> Encoding -> Encoding) -> Encoding -> m -> Encoding)
    -> m
    -> Encoding
    encodeMapSkel IntMap a -> Int
    forall a. IntMap a -> Int
    IntMap.size (Int -> a -> Encoding -> Encoding)
    -> Encoding -> IntMap a -> Encoding
    forall a b. (Int -> a -> b -> b) -> b -> IntMap a -> b
    IntMap.foldrWithKey
      decode :: forall s. Decoder s (IntMap a)
    decode = ([(Int, a)] -> IntMap a) -> Decoder s (IntMap a)
    forall k v m s.
    (Serialise k, Serialise v) =>
    ([(k, v)] -> m) -> Decoder s m
    decodeMapSkel [(Int, a)] -> IntMap a
    forall a. [(Int, a)] -> IntMap a
    IntMap.fromList

    -- | @since 0.2.0.0
    instance (Serialise k, Hashable k, Eq k, Serialise v) =>
      Serialise (HashMap.HashMap k v) where
      encode :: HashMap k v -> Encoding
    encode = (HashMap k v -> Int)
    -> ((k -> v -> Encoding -> Encoding)
        -> Encoding -> HashMap k v -> Encoding)
    -> HashMap k v
    -> Encoding
    forall k v m.
    (Serialise k, Serialise v) =>
    (m -> Int)
    -> ((k -> v -> Encoding -> Encoding) -> Encoding -> m -> Encoding)
    -> m
    -> Encoding
    encodeMapSkel HashMap k v -> Int
    forall k v. HashMap k v -> Int
    HashMap.size (k -> v -> Encoding -> Encoding)
    -> Encoding -> HashMap k v -> Encoding
    forall k v a. (k -> v -> a -> a) -> a -> HashMap k v -> a
    HashMap.foldrWithKey
      decode :: forall s. Decoder s (HashMap k v)
    decode = ([(k, v)] -> HashMap k v) -> Decoder s (HashMap k v)
    forall k v m s.
    (Serialise k, Serialise v) =>
    ([(k, v)] -> m) -> Decoder s m
    decodeMapSkel [(k, v)] -> HashMap k v
    forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
    HashMap.fromList

    --------------------------------------------------------------------------------
    -- Misc base package instances

    -- | @since 0.2.0.0
    instance Serialise Version where
        encode :: Version -> Encoding
    encode (Version [Int]
    ns [String]
    ts) = Word -> Encoding
    encodeListLen Word
    3
                              Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    0 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> [Int] -> Encoding
    forall a. Serialise a => a -> Encoding
    encode [Int]
    ns Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> [String] -> Encoding
    forall a. Serialise a => a -> Encoding
    encode [String]
    ts
        decode :: forall s. Decoder s Version
    decode = do
          len <- Decoder s Int
    forall s. Decoder s Int
    decodeListLen
          tag <- decodeWord
          case tag of
            Word
    0 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    3
              -> do !x <- Decoder s [Int]
    forall s. Decoder s [Int]
    forall a s. Serialise a => Decoder s a
    decode
                    !y <- decode
                    return (Version x y)
            Word
    _ -> String -> Decoder s Version
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "unexpected tag"

    -- | @since 0.2.0.0
    instance Serialise Fingerprint where
        encode :: Fingerprint -> Encoding
    encode (Fingerprint Word64
    w1 Word64
    w2) = Word -> Encoding
    encodeListLen Word
    3
                                  Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    0
                                  Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word64 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Word64
    w1
                                  Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word64 -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Word64
    w2
        decode :: forall s. Decoder s Fingerprint
    decode = do
          Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    3
          tag <- Decoder s Word
    forall s. Decoder s Word
    decodeWord
          case tag of
            Word
    0 -> do !w1 <- Decoder s Word64
    forall s. Decoder s Word64
    forall a s. Serialise a => Decoder s a
    decode
                    !w2 <- decode
                    return $! Fingerprint w1 w2
            Word
    _ -> String -> Decoder s Fingerprint
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "unexpected tag"

    -- | @since 0.2.0.0
    instance Serialise TyCon where
    #if MIN_VERSION_base(4,10,0)
      encode :: TyCon -> Encoding
    encode TyCon
    tc
        = Word -> Encoding
    encodeListLen Word
    6
       Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    0
       Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> String -> Encoding
    forall a. Serialise a => a -> Encoding
    encode (TyCon -> String
    tyConPackage TyCon
    tc)
       Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> String -> Encoding
    forall a. Serialise a => a -> Encoding
    encode (TyCon -> String
    tyConModule TyCon
    tc)
       Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> String -> Encoding
    forall a. Serialise a => a -> Encoding
    encode (TyCon -> String
    tyConName TyCon
    tc)
       Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Int -> Encoding
    forall a. Serialise a => a -> Encoding
    encode (TyCon -> Int
    tyConKindArgs TyCon
    tc)
       Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> KindRep -> Encoding
    forall a. Serialise a => a -> Encoding
    encode (TyCon -> KindRep
    tyConKindRep TyCon
    tc)
      decode :: forall s. Decoder s TyCon
    decode = do
        Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    6
        tag <- Decoder s Word
    forall s. Decoder s Word
    decodeWord
        case tag of
          Word
    0 -> String -> String -> String -> Int -> KindRep -> TyCon
    mkTyCon (String -> String -> String -> Int -> KindRep -> TyCon)
    -> Decoder s String
    -> Decoder s (String -> String -> Int -> KindRep -> TyCon)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s String
    forall s. Decoder s String
    forall a s. Serialise a => Decoder s a
    decode Decoder s (String -> String -> Int -> KindRep -> TyCon)
    -> Decoder s String
    -> Decoder s (String -> Int -> KindRep -> TyCon)
    forall a b. Decoder s (a -> b) -> Decoder s a -> Decoder s b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Decoder s String
    forall s. Decoder s String
    forall a s. Serialise a => Decoder s a
    decode Decoder s (String -> Int -> KindRep -> TyCon)
    -> Decoder s String -> Decoder s (Int -> KindRep -> TyCon)
    forall a b. Decoder s (a -> b) -> Decoder s a -> Decoder s b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Decoder s String
    forall s. Decoder s String
    forall a s. Serialise a => Decoder s a
    decode Decoder s (Int -> KindRep -> TyCon)
    -> Decoder s Int -> Decoder s (KindRep -> TyCon)
    forall a b. Decoder s (a -> b) -> Decoder s a -> Decoder s b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Decoder s Int
    forall s. Decoder s Int
    forall a s. Serialise a => Decoder s a
    decode Decoder s (KindRep -> TyCon)
    -> Decoder s KindRep -> Decoder s TyCon
    forall a b. Decoder s (a -> b) -> Decoder s a -> Decoder s b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Decoder s KindRep
    forall s. Decoder s KindRep
    forall a s. Serialise a => Decoder s a
    decode
          Word
    _ -> String -> Decoder s TyCon
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "unexpected tag"
    #elif MIN_VERSION_base(4,9,0)
      encode tycon
        = encodeListLen 4
       <> encodeWord 0
       <> encode (tyConPackage tycon)
       <> encode (tyConModule  tycon)
       <> encode (tyConName    tycon)
    #else
      encode (TyCon _ pkg modname name)
        = encodeListLen 4
       <> encodeWord 0
       <> encode pkg
       <> encode modname
       <> encode name
    #endif

    #if !MIN_VERSION_base(4,10,0)
      decode = do
        decodeListLenOf 4
        tag <- decodeWord
        case tag of
          0 -> do !pkg     <- decode
                  !modname <- decode
                  !name    <- decode
                  return $! mkTyCon3 pkg modname name
          _ -> fail "unexpected tag"
    #endif

    #if MIN_VERSION_base(4,10,0)
    -- | @since 0.2.0.0
    instance Serialise VecCount where
      encode :: VecCount -> Encoding
    encode VecCount
    c = Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord (Int -> Word
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word) -> Int -> Word
    forall a b. (a -> b) -> a -> b
    $ VecCount -> Int
    forall a. Enum a => a -> Int
    fromEnum VecCount
    c)
      decode :: forall s. Decoder s VecCount
    decode = do
        Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    1
        Int -> VecCount
    forall a. Enum a => Int -> a
    toEnum (Int -> VecCount) -> (Word -> Int) -> Word -> VecCount
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word -> VecCount) -> Decoder s Word -> Decoder s VecCount
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Word
    forall s. Decoder s Word
    decodeWord

    -- | @since 0.2.0.0
    instance Serialise VecElem where
      encode :: VecElem -> Encoding
    encode VecElem
    e = Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord (Int -> Word
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word) -> Int -> Word
    forall a b. (a -> b) -> a -> b
    $ VecElem -> Int
    forall a. Enum a => a -> Int
    fromEnum VecElem
    e)
      decode :: forall s. Decoder s VecElem
    decode = do
        Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    1
        Int -> VecElem
    forall a. Enum a => Int -> a
    toEnum (Int -> VecElem) -> (Word -> Int) -> Word -> VecElem
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word -> VecElem) -> Decoder s Word -> Decoder s VecElem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Word
    forall s. Decoder s Word
    decodeWord

    #if MIN_VERSION_base(4,16,0)
    -- | @since 0.2.6.0
    instance Serialise Levity where
      encode :: Levity -> Encoding
    encode Levity
    lev = Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord (Int -> Word
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word) -> Int -> Word
    forall a b. (a -> b) -> a -> b
    $ Levity -> Int
    forall a. Enum a => a -> Int
    fromEnum Levity
    lev)
      decode :: forall s. Decoder s Levity
    decode = do
        Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    1
        Int -> Levity
    forall a. Enum a => Int -> a
    toEnum (Int -> Levity) -> (Word -> Int) -> Word -> Levity
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word -> Levity) -> Decoder s Word -> Decoder s Levity
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Word
    forall s. Decoder s Word
    decodeWord
    #endif

    -- | @since 0.2.0.0
    instance Serialise RuntimeRep where
      encode :: RuntimeRep -> Encoding
    encode RuntimeRep
    rr =
        case RuntimeRep
    rr of
          VecRep VecCount
    a VecElem
    b    -> Word -> Encoding
    encodeListLen Word
    3 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    0 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> VecCount -> Encoding
    forall a. Serialise a => a -> Encoding
    encode VecCount
    a Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> VecElem -> Encoding
    forall a. Serialise a => a -> Encoding
    encode VecElem
    b
          TupleRep [RuntimeRep]
    reps -> Word -> Encoding
    encodeListLen Word
    2 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> [RuntimeRep] -> Encoding
    forall a. Serialise a => a -> Encoding
    encode [RuntimeRep]
    reps
          SumRep [RuntimeRep]
    reps   -> Word -> Encoding
    encodeListLen Word
    2 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    2 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> [RuntimeRep] -> Encoding
    forall a. Serialise a => a -> Encoding
    encode [RuntimeRep]
    reps
    #if MIN_VERSION_base(4,16,0)
          BoxedRep Levity
    lev  -> Word -> Encoding
    encodeListLen Word
    2 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    3 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Levity -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Levity
    lev
    #else
          LiftedRep     -> encodeListLen 1 <> encodeWord 3
          UnliftedRep   -> encodeListLen 1 <> encodeWord 4
    #endif
          RuntimeRep
    IntRep        -> Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    5
          RuntimeRep
    WordRep       -> Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    6
          RuntimeRep
    Int64Rep      -> Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    7
          RuntimeRep
    Word64Rep     -> Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    8
          RuntimeRep
    AddrRep       -> Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    9
          RuntimeRep
    FloatRep      -> Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    10
          RuntimeRep
    DoubleRep     -> Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    11
    #if MIN_VERSION_base(4,13,0)
          RuntimeRep
    Int8Rep       -> Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    12
          RuntimeRep
    Int16Rep      -> Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    13
          RuntimeRep
    Word8Rep      -> Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    14
          RuntimeRep
    Word16Rep     -> Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    15
    #endif
    #if MIN_VERSION_base(4,14,0)
          RuntimeRep
    Int32Rep      -> Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    16
          RuntimeRep
    Word32Rep     -> Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    17
    #endif

      decode :: forall s. Decoder s RuntimeRep
    decode = do
        len <- Decoder s Int
    forall s. Decoder s Int
    decodeListLen
        tag <- decodeWord
        case tag of
          Word
    0  | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    3 -> VecCount -> VecElem -> RuntimeRep
    VecRep (VecCount -> VecElem -> RuntimeRep)
    -> Decoder s VecCount -> Decoder s (VecElem -> RuntimeRep)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s VecCount
    forall s. Decoder s VecCount
    forall a s. Serialise a => Decoder s a
    decode Decoder s (VecElem -> RuntimeRep)
    -> Decoder s VecElem -> Decoder s RuntimeRep
    forall a b. Decoder s (a -> b) -> Decoder s a -> Decoder s b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Decoder s VecElem
    forall s. Decoder s VecElem
    forall a s. Serialise a => Decoder s a
    decode
          Word
    1  | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    2 -> [RuntimeRep] -> RuntimeRep
    TupleRep ([RuntimeRep] -> RuntimeRep)
    -> Decoder s [RuntimeRep] -> Decoder s RuntimeRep
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s [RuntimeRep]
    forall s. Decoder s [RuntimeRep]
    forall a s. Serialise a => Decoder s a
    decode
          Word
    2  | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    2 -> [RuntimeRep] -> RuntimeRep
    SumRep ([RuntimeRep] -> RuntimeRep)
    -> Decoder s [RuntimeRep] -> Decoder s RuntimeRep
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s [RuntimeRep]
    forall s. Decoder s [RuntimeRep]
    forall a s. Serialise a => Decoder s a
    decode
    #if MIN_VERSION_base(4,16,0)
          Word
    3  | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    2 -> Levity -> RuntimeRep
    BoxedRep (Levity -> RuntimeRep) -> Decoder s Levity -> Decoder s RuntimeRep
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Levity
    forall s. Decoder s Levity
    forall a s. Serialise a => Decoder s a
    decode
    #else
          3  | len == 1 -> pure LiftedRep
          4  | len == 1 -> pure UnliftedRep
    #endif
          Word
    5  | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 -> RuntimeRep -> Decoder s RuntimeRep
    forall a. a -> Decoder s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure RuntimeRep
    IntRep
          Word
    6  | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 -> RuntimeRep -> Decoder s RuntimeRep
    forall a. a -> Decoder s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure RuntimeRep
    WordRep
          Word
    7  | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 -> RuntimeRep -> Decoder s RuntimeRep
    forall a. a -> Decoder s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure RuntimeRep
    Int64Rep
          Word
    8  | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 -> RuntimeRep -> Decoder s RuntimeRep
    forall a. a -> Decoder s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure RuntimeRep
    Word64Rep
          Word
    9  | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 -> RuntimeRep -> Decoder s RuntimeRep
    forall a. a -> Decoder s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure RuntimeRep
    AddrRep
          Word
    10 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 -> RuntimeRep -> Decoder s RuntimeRep
    forall a. a -> Decoder s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure RuntimeRep
    FloatRep
          Word
    11 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 -> RuntimeRep -> Decoder s RuntimeRep
    forall a. a -> Decoder s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure RuntimeRep
    DoubleRep
    #if MIN_VERSION_base(4,13,0)
          Word
    12 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 -> RuntimeRep -> Decoder s RuntimeRep
    forall a. a -> Decoder s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure RuntimeRep
    Int8Rep
          Word
    13 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 -> RuntimeRep -> Decoder s RuntimeRep
    forall a. a -> Decoder s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure RuntimeRep
    Int16Rep
          Word
    14 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 -> RuntimeRep -> Decoder s RuntimeRep
    forall a. a -> Decoder s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure RuntimeRep
    Word8Rep
          Word
    15 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 -> RuntimeRep -> Decoder s RuntimeRep
    forall a. a -> Decoder s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure RuntimeRep
    Word16Rep
    #endif
    #if MIN_VERSION_base(4,14,0)
          Word
    16 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 -> RuntimeRep -> Decoder s RuntimeRep
    forall a. a -> Decoder s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure RuntimeRep
    Int32Rep
          Word
    17 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 -> RuntimeRep -> Decoder s RuntimeRep
    forall a. a -> Decoder s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure RuntimeRep
    Word32Rep
    #endif
          Word
    _             -> String -> Decoder s RuntimeRep
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "Data.Serialise.Binary.CBOR.getRuntimeRep: invalid tag"

    -- | @since 0.2.0.0
    instance Serialise KindRep where
      encode :: KindRep -> Encoding
    encode KindRep
    rep =
        case KindRep
    rep of
          KindRepTyConApp TyCon
    tc [KindRep]
    k  -> Word -> Encoding
    encodeListLen Word
    3 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    0 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> TyCon -> Encoding
    forall a. Serialise a => a -> Encoding
    encode TyCon
    tc Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> [KindRep] -> Encoding
    forall a. Serialise a => a -> Encoding
    encode [KindRep]
    k
          KindRepVar Int
    bndr       -> Word -> Encoding
    encodeListLen Word
    2 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Int -> Encoding
    forall a. Serialise a => a -> Encoding
    encode Int
    bndr
          KindRepApp KindRep
    a KindRep
    b        -> Word -> Encoding
    encodeListLen Word
    3 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    2 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> KindRep -> Encoding
    forall a. Serialise a => a -> Encoding
    encode KindRep
    a Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> KindRep -> Encoding
    forall a. Serialise a => a -> Encoding
    encode KindRep
    b
          KindRepFun KindRep
    a KindRep
    b        -> Word -> Encoding
    encodeListLen Word
    3 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    3 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> KindRep -> Encoding
    forall a. Serialise a => a -> Encoding
    encode KindRep
    a Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> KindRep -> Encoding
    forall a. Serialise a => a -> Encoding
    encode KindRep
    b
          KindRepTYPE RuntimeRep
    r         -> Word -> Encoding
    encodeListLen Word
    2 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    4 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> RuntimeRep -> Encoding
    forall a. Serialise a => a -> Encoding
    encode RuntimeRep
    r
          KindRepTypeLit TypeLitSort
    sort String
    r -> Word -> Encoding
    encodeListLen Word
    3 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    5 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> TypeLitSort -> Encoding
    forall a. Serialise a => a -> Encoding
    encode TypeLitSort
    sort Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> String -> Encoding
    forall a. Serialise a => a -> Encoding
    encode String
    r

      decode :: forall s. Decoder s KindRep
    decode = do
        len <- Decoder s Int
    forall s. Decoder s Int
    decodeListLen
        tag <- decodeWord
        case tag of
          Word
    0 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    3 -> TyCon -> [KindRep] -> KindRep
    KindRepTyConApp (TyCon -> [KindRep] -> KindRep)
    -> Decoder s TyCon -> Decoder s ([KindRep] -> KindRep)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s TyCon
    forall s. Decoder s TyCon
    forall a s. Serialise a => Decoder s a
    decode Decoder s ([KindRep] -> KindRep)
    -> Decoder s [KindRep] -> Decoder s KindRep
    forall a b. Decoder s (a -> b) -> Decoder s a -> Decoder s b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Decoder s [KindRep]
    forall s. Decoder s [KindRep]
    forall a s. Serialise a => Decoder s a
    decode
          Word
    1 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    2 -> Int -> KindRep
    KindRepVar (Int -> KindRep) -> Decoder s Int -> Decoder s KindRep
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Int
    forall s. Decoder s Int
    forall a s. Serialise a => Decoder s a
    decode
          Word
    2 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    3 -> KindRep -> KindRep -> KindRep
    KindRepApp (KindRep -> KindRep -> KindRep)
    -> Decoder s KindRep -> Decoder s (KindRep -> KindRep)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s KindRep
    forall s. Decoder s KindRep
    forall a s. Serialise a => Decoder s a
    decode Decoder s (KindRep -> KindRep)
    -> Decoder s KindRep -> Decoder s KindRep
    forall a b. Decoder s (a -> b) -> Decoder s a -> Decoder s b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Decoder s KindRep
    forall s. Decoder s KindRep
    forall a s. Serialise a => Decoder s a
    decode
          Word
    3 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    3 -> KindRep -> KindRep -> KindRep
    KindRepFun (KindRep -> KindRep -> KindRep)
    -> Decoder s KindRep -> Decoder s (KindRep -> KindRep)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s KindRep
    forall s. Decoder s KindRep
    forall a s. Serialise a => Decoder s a
    decode Decoder s (KindRep -> KindRep)
    -> Decoder s KindRep -> Decoder s KindRep
    forall a b. Decoder s (a -> b) -> Decoder s a -> Decoder s b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Decoder s KindRep
    forall s. Decoder s KindRep
    forall a s. Serialise a => Decoder s a
    decode
          Word
    4 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    2 -> RuntimeRep -> KindRep
    KindRepTYPE (RuntimeRep -> KindRep)
    -> Decoder s RuntimeRep -> Decoder s KindRep
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s RuntimeRep
    forall s. Decoder s RuntimeRep
    forall a s. Serialise a => Decoder s a
    decode
          Word
    5 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    3 -> TypeLitSort -> String -> KindRep
    KindRepTypeLit (TypeLitSort -> String -> KindRep)
    -> Decoder s TypeLitSort -> Decoder s (String -> KindRep)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s TypeLitSort
    forall s. Decoder s TypeLitSort
    forall a s. Serialise a => Decoder s a
    decode Decoder s (String -> KindRep)
    -> Decoder s String -> Decoder s KindRep
    forall a b. Decoder s (a -> b) -> Decoder s a -> Decoder s b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Decoder s String
    forall s. Decoder s String
    forall a s. Serialise a => Decoder s a
    decode
          Word
    _            -> String -> Decoder s KindRep
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "Data.Serialise.Binary.CBOR.getKindRep: invalid tag"

    -- | @since 0.2.0.0
    instance Serialise TypeLitSort where
      encode :: TypeLitSort -> Encoding
    encode TypeLitSort
    n
        = Word -> Encoding
    encodeListLen Word
    1
       Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> case TypeLitSort
    n of
            TypeLitSort
    TypeLitSymbol -> Word -> Encoding
    encodeWord Word
    0
            TypeLitSort
    TypeLitNat    -> Word -> Encoding
    encodeWord Word
    1
    #if MIN_VERSION_base(4,16,0)
            TypeLitSort
    TypeLitChar   -> Word -> Encoding
    encodeWord Word
    2
    #endif
      decode :: forall s. Decoder s TypeLitSort
    decode = do
        Int -> Decoder s ()
    forall s. Int -> Decoder s ()
    decodeListLenOf Int
    1
        tag <- Decoder s Word
    forall s. Decoder s Word
    decodeWord
        case tag of
          Word
    0 -> TypeLitSort -> Decoder s TypeLitSort
    forall a. a -> Decoder s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TypeLitSort
    TypeLitSymbol
          Word
    1 -> TypeLitSort -> Decoder s TypeLitSort
    forall a. a -> Decoder s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TypeLitSort
    TypeLitNat
    #if MIN_VERSION_base(4,16,0)
          Word
    2 -> TypeLitSort -> Decoder s TypeLitSort
    forall a. a -> Decoder s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TypeLitSort
    TypeLitChar
    #endif
          Word
    _ -> String -> Decoder s TypeLitSort
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "Data.Serialise.Binary.CBOR.putTypeLitSort: invalid tag"

    decodeSomeTypeRep :: Decoder s SomeTypeRep
    decodeSomeTypeRep :: forall s. Decoder s SomeTypeRep
    decodeSomeTypeRep = do
        len <- Decoder s Int
    forall s. Decoder s Int
    decodeListLen
        tag <- decodeWord
        case tag of
          Word
    0 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 ->
                  SomeTypeRep -> Decoder s SomeTypeRep
    forall a. a -> Decoder s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (SomeTypeRep -> Decoder s SomeTypeRep)
    -> SomeTypeRep -> Decoder s SomeTypeRep
    forall a b. (a -> b) -> a -> b
    $! TypeRep (*) -> SomeTypeRep
    forall k (a :: k). TypeRep a -> SomeTypeRep
    SomeTypeRep (TypeRep (*)
    forall {k} (a :: k). Typeable a => TypeRep a
    typeRep :: TypeRep Type)
          Word
    1 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    3 -> do
                  !con <- Decoder s TyCon
    forall s. Decoder s TyCon
    forall a s. Serialise a => Decoder s a
    decode
                  !ks <- decode
                  return $! SomeTypeRep $ mkTrCon con ks
          Word
    2 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    3 -> do
                  SomeTypeRep f <- Decoder s SomeTypeRep
    forall s. Decoder s SomeTypeRep
    decodeSomeTypeRep
                  SomeTypeRep x <- decodeSomeTypeRep
                  case typeRepKind f of
                    Fun TypeRep arg
    arg TypeRep res
    res ->
                        case TypeRep arg
    arg TypeRep arg -> TypeRep k -> Maybe (arg :~~: k)
    forall k1 k2 (a :: k1) (b :: k2).
    TypeRep a -> TypeRep b -> Maybe (a :~~: b)
    `eqTypeRep` TypeRep a -> TypeRep k
    forall k (a :: k). TypeRep a -> TypeRep k
    typeRepKind TypeRep a
    x of
                          Just arg :~~: k
    HRefl -> do
                              case TypeRep res -> TypeRep (TYPE r2)
    forall k (a :: k). TypeRep a -> TypeRep k
    typeRepKind TypeRep res
    res TypeRep (TYPE r2) -> TypeRep (*) -> Maybe (TYPE r2 :~~: *)
    forall k1 k2 (a :: k1) (b :: k2).
    TypeRep a -> TypeRep b -> Maybe (a :~~: b)
    `eqTypeRep` (TypeRep (*)
    forall {k} (a :: k). Typeable a => TypeRep a
    typeRep :: TypeRep Type) of
                                Just TYPE r2 :~~: *
    HRefl -> SomeTypeRep -> Decoder s SomeTypeRep
    forall a. a -> Decoder s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (SomeTypeRep -> Decoder s SomeTypeRep)
    -> SomeTypeRep -> Decoder s SomeTypeRep
    forall a b. (a -> b) -> a -> b
    $! TypeRep (a a) -> SomeTypeRep
    forall k (a :: k). TypeRep a -> SomeTypeRep
    SomeTypeRep (TypeRep a -> TypeRep a -> TypeRep (a a)
    forall k1 k2 (a :: k1 -> k2) (b :: k1).
    TypeRep a -> TypeRep b -> TypeRep (a b)
    mkTrApp TypeRep a
    TypeRep a
    f TypeRep a
    x)
                                Maybe (TYPE r2 :~~: *)
    _          -> String -> [String] -> Decoder s SomeTypeRep
    forall {m :: * -> *} {a}. MonadFail m => String -> [String] -> m a
    failure String
    "Kind mismatch" []
                          Maybe (arg :~~: k)
    _ -> String -> [String] -> Decoder s SomeTypeRep
    forall {m :: * -> *} {a}. MonadFail m => String -> [String] -> m a
    failure String
    "Kind mismatch"
                               [ String
    "Found argument of kind:      " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ TypeRep k -> String
    forall a. Show a => a -> String
    show (TypeRep a -> TypeRep k
    forall k (a :: k). TypeRep a -> TypeRep k
    typeRepKind TypeRep a
    x)
                               , String
    "Where the constructor:       " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ TypeRep a -> String
    forall a. Show a => a -> String
    show TypeRep a
    f
                               , String
    "Expects an argument of kind: " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ TypeRep arg -> String
    forall a. Show a => a -> String
    show TypeRep arg
    arg
                               ]
                    TypeRep k
    _ -> String -> [String] -> Decoder s SomeTypeRep
    forall {m :: * -> *} {a}. MonadFail m => String -> [String] -> m a
    failure String
    "Applied non-arrow type"
                         [ String
    "Applied type: " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ TypeRep a -> String
    forall a. Show a => a -> String
    show TypeRep a
    f
                         , String
    "To argument:  " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ TypeRep a -> String
    forall a. Show a => a -> String
    show TypeRep a
    x
                         ]
          Word
    3 | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    3 -> do
                  SomeTypeRep arg <- Decoder s SomeTypeRep
    forall s. Decoder s SomeTypeRep
    decodeSomeTypeRep
                  SomeTypeRep res <- decodeSomeTypeRep
                  case typeRepKind arg `eqTypeRep` (typeRep :: TypeRep Type) of
                    Just k :~~: *
    HRefl ->
                        case  TypeRep a -> TypeRep k
    forall k (a :: k). TypeRep a -> TypeRep k
    typeRepKind TypeRep a
    res TypeRep k -> TypeRep (*) -> Maybe (k :~~: *)
    forall k1 k2 (a :: k1) (b :: k2).
    TypeRep a -> TypeRep b -> Maybe (a :~~: b)
    `eqTypeRep` (TypeRep (*)
    forall {k} (a :: k). Typeable a => TypeRep a
    typeRep :: TypeRep Type) of
                          Just k :~~: *
    HRefl -> SomeTypeRep -> Decoder s SomeTypeRep
    forall a. a -> Decoder s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (SomeTypeRep -> Decoder s SomeTypeRep)
    -> SomeTypeRep -> Decoder s SomeTypeRep
    forall a b. (a -> b) -> a -> b
    $! TypeRep (a -> a) -> SomeTypeRep
    forall k (a :: k). TypeRep a -> SomeTypeRep
    SomeTypeRep (TypeRep (a -> a) -> SomeTypeRep)
    -> TypeRep (a -> a) -> SomeTypeRep
    forall a b. (a -> b) -> a -> b
    $ TypeRep a -> TypeRep a -> TypeRep (a -> a)
    forall k (fun :: k) arg res.
    (k ~ *, fun ~~ (arg -> res)) =>
    TypeRep arg -> TypeRep res -> TypeRep fun
    Fun TypeRep a
    TypeRep a
    arg TypeRep a
    TypeRep a
    res
                          Maybe (k :~~: *)
    Nothing -> String -> [String] -> Decoder s SomeTypeRep
    forall {m :: * -> *} {a}. MonadFail m => String -> [String] -> m a
    failure String
    "Kind mismatch" []
                    Maybe (k :~~: *)
    Nothing -> String -> [String] -> Decoder s SomeTypeRep
    forall {m :: * -> *} {a}. MonadFail m => String -> [String] -> m a
    failure String
    "Kind mismatch" []
          Word
    _ -> String -> [String] -> Decoder s SomeTypeRep
    forall {m :: * -> *} {a}. MonadFail m => String -> [String] -> m a
    failure String
    "unexpected tag"
               [ String
    "Tag: " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Word -> String
    forall a. Show a => a -> String
    show Word
    tag
               , String
    "Len: " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    len ]
      where
        failure :: String -> [String] -> m a
    failure String
    description [String]
    info =
            String -> m a
    forall a. String -> m a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail (String -> m a) -> String -> m a
    forall a b. (a -> b) -> a -> b
    $ [String] -> String
    unlines ([String] -> String) -> [String] -> String
    forall a b. (a -> b) -> a -> b
    $ [ String
    "Codec.CBOR.Class.decodeSomeTypeRep: "String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++String
    description ]
                             [String] -> [String] -> [String]
    forall a. [a] -> [a] -> [a]
    ++ (String -> String) -> [String] -> [String]
    forall a b. (a -> b) -> [a] -> [b]
    map (String
    "    "String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++) [String]
    info

    encodeTypeRep :: TypeRep a -> Encoding
    encodeTypeRep :: forall {k} (a :: k). TypeRep a -> Encoding
    encodeTypeRep TypeRep a
    rep  -- Handle Type specially since it's so common
      | Just a :~~: *
    HRefl <- TypeRep a
    rep TypeRep a -> TypeRep (*) -> Maybe (a :~~: *)
    forall k1 k2 (a :: k1) (b :: k2).
    TypeRep a -> TypeRep b -> Maybe (a :~~: b)
    `eqTypeRep` (TypeRep (*)
    forall {k} (a :: k). Typeable a => TypeRep a
    typeRep :: TypeRep Type)
      = Word -> Encoding
    encodeListLen Word
    1
     Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    0
    encodeTypeRep (Con' TyCon
    con [SomeTypeRep]
    ks)
      = Word -> Encoding
    encodeListLen Word
    3
     Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    1
     Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> TyCon -> Encoding
    forall a. Serialise a => a -> Encoding
    encode TyCon
    con
     Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> [SomeTypeRep] -> Encoding
    forall a. Serialise a => a -> Encoding
    encode [SomeTypeRep]
    ks
    encodeTypeRep (App TypeRep a
    f TypeRep b
    x)
      = Word -> Encoding
    encodeListLen Word
    3
     Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    2
     Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> TypeRep a -> Encoding
    forall {k} (a :: k). TypeRep a -> Encoding
    encodeTypeRep TypeRep a
    f
     Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> TypeRep b -> Encoding
    forall {k} (a :: k). TypeRep a -> Encoding
    encodeTypeRep TypeRep b
    x
    encodeTypeRep (Fun TypeRep arg
    arg TypeRep res
    res)
      = Word -> Encoding
    encodeListLen Word
    3
     Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    3
     Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> TypeRep arg -> Encoding
    forall {k} (a :: k). TypeRep a -> Encoding
    encodeTypeRep TypeRep arg
    arg
     Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> TypeRep res -> Encoding
    forall {k} (a :: k). TypeRep a -> Encoding
    encodeTypeRep TypeRep res
    res

    -- | @since 0.2.0.0
    instance Typeable a => Serialise (TypeRep (a :: k)) where
      encode :: TypeRep a -> Encoding
    encode = TypeRep a -> Encoding
    forall {k} (a :: k). TypeRep a -> Encoding
    encodeTypeRep
      decode :: forall s. Decoder s (TypeRep a)
    decode = do
          SomeTypeRep rep <- Decoder s SomeTypeRep
    forall s. Decoder s SomeTypeRep
    decodeSomeTypeRep
          case rep `eqTypeRep` expected of
            Just a :~~: a
    HRefl -> TypeRep a -> Decoder s (TypeRep a)
    forall a. a -> Decoder s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TypeRep a
    TypeRep a
    rep
            Maybe (a :~~: a)
    Nothing    -> String -> Decoder s (TypeRep a)
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail (String -> Decoder s (TypeRep a))
    -> String -> Decoder s (TypeRep a)
    forall a b. (a -> b) -> a -> b
    $ [String] -> String
    unlines
                          [ String
    "Codec.CBOR.Class.decode(TypeRep): Type mismatch"
                          , String
    "    Deserialised type: " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ TypeRep a -> String
    forall a. Show a => a -> String
    show TypeRep a
    rep
                          , String
    "    Expected type:     " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ TypeRep a -> String
    forall a. Show a => a -> String
    show TypeRep a
    expected
                          ]
        where expected :: TypeRep a
    expected = TypeRep a
    forall {k} (a :: k). Typeable a => TypeRep a
    typeRep :: TypeRep a

    -- | @since 0.2.0.0
    instance Serialise SomeTypeRep where
      encode :: SomeTypeRep -> Encoding
    encode (SomeTypeRep TypeRep a
    rep) = TypeRep a -> Encoding
    forall {k} (a :: k). TypeRep a -> Encoding
    encodeTypeRep TypeRep a
    rep
      decode :: forall s. Decoder s SomeTypeRep
    decode = Decoder s SomeTypeRep
    forall s. Decoder s SomeTypeRep
    decodeSomeTypeRep

    #else

    -- | @since 0.2.0.0
    instance Serialise TypeRep where
    #if MIN_VERSION_base(4,8,0)
      encode (TypeRep fp tycon kirep tyrep)
        = encodeListLen 5
       <> encodeWord 0
       <> encode fp
       <> encode tycon
       <> encode kirep
       <> encode tyrep

      decode = do
        decodeListLenOf 5
        tag <- decodeWord
        case tag of
          0 -> do !fp    <- decode
                  !tycon <- decode
                  !kirep <- decode
                  !tyrep <- decode
                  return $! TypeRep fp tycon kirep tyrep
          _ -> fail "unexpected tag"
    #else
      encode (TypeRep fp tycon tyrep)
        = encodeListLen 4
       <> encodeWord 0
       <> encode fp
       <> encode tycon
       <> encode tyrep

      decode = do
        decodeListLenOf 4
        tag <- decodeWord
        case tag of
          0 -> do !fp    <- decode
                  !tycon <- decode
                  !tyrep <- decode
                  return $! TypeRep fp tycon tyrep
          _ -> fail "unexpected tag"
    #endif

    #endif /* !MIN_VERBOSE_base(4,10,0) */

    --------------------------------------------------------------------------------
    -- Time instances
    --
    -- CBOR has some special encodings for times/timestamps

    -- | 'UTCTime' is encoded using the extended time format which is currently in
    -- Internet Draft state,
    -- https://tools.ietf.org/html/draft-bormann-cbor-time-tag-00.
    --
    -- @since 0.2.0.0
    instance Serialise UTCTime where
        encode :: UTCTime -> Encoding
    encode UTCTime
    t =
            Word -> Encoding
    encodeTag Word
    1000
            Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeMapLen Word
    2
            Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Int64 -> Encoding
    encodeInt64 Int64
    secs
            Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Int -> Encoding
    encodeInt (-Int
    12) Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word64 -> Encoding
    encodeWord64 Word64
    psecs
          where
            (Int64
    secs, POSIXTime
    frac) = case POSIXTime -> (Int64, POSIXTime)
    forall b. Integral b => POSIXTime -> (b, POSIXTime)
    forall a b. (RealFrac a, Integral b) => a -> (b, a)
    properFraction (POSIXTime -> (Int64, POSIXTime))
    -> POSIXTime -> (Int64, POSIXTime)
    forall a b. (a -> b) -> a -> b
    $ UTCTime -> POSIXTime
    utcTimeToPOSIXSeconds UTCTime
    t of
                             -- fractional part must be positive
                             (Int64
    secs', POSIXTime
    frac')
                               | POSIXTime
    frac' POSIXTime -> POSIXTime -> Bool
    forall a. Ord a => a -> a -> Bool
    < POSIXTime
    0  -> (Int64
    secs' Int64 -> Int64 -> Int64
    forall a. Num a => a -> a -> a
    - Int64
    1, POSIXTime
    frac' POSIXTime -> POSIXTime -> POSIXTime
    forall a. Num a => a -> a -> a
    + POSIXTime
    1)
                               | Bool
    otherwise -> (Int64
    secs', POSIXTime
    frac')
            psecs :: Word64
    psecs = POSIXTime -> Word64
    forall b. Integral b => POSIXTime -> b
    forall a b. (RealFrac a, Integral b) => a -> b
    round (POSIXTime -> Word64) -> POSIXTime -> Word64
    forall a b. (a -> b) -> a -> b
    $ POSIXTime
    frac POSIXTime -> POSIXTime -> POSIXTime
    forall a. Num a => a -> a -> a
    * POSIXTime
    1000000000000

        decode :: forall s. Decoder s UTCTime
    decode = do
          tag <- Decoder s Word
    forall s. Decoder s Word
    decodeTag
          case tag of
            Word
    0 -> do str <- Decoder s Text
    forall s. Decoder s Text
    decodeString
                    case parseUTCrfc3339 (Text.unpack str) of
                      Just UTCTime
    t  -> UTCTime -> Decoder s UTCTime
    forall a. a -> Decoder s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (UTCTime -> Decoder s UTCTime) -> UTCTime -> Decoder s UTCTime
    forall a b. (a -> b) -> a -> b
    $! UTCTime -> UTCTime
    forceUTCTime UTCTime
    t
                      Maybe UTCTime
    Nothing -> String -> Decoder s UTCTime
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "Could not parse RFC3339 date"

            Word
    1 -> do
              tt <- Decoder s TokenType
    forall s. Decoder s TokenType
    peekTokenType
              case tt of
                TokenType
    TypeUInt    -> Word -> UTCTime
    forall a. Integral a => a -> UTCTime
    utcFromIntegral (Word -> UTCTime) -> Decoder s Word -> Decoder s UTCTime
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Word
    forall s. Decoder s Word
    decodeWord
                TokenType
    TypeUInt64  -> Word64 -> UTCTime
    forall a. Integral a => a -> UTCTime
    utcFromIntegral (Word64 -> UTCTime) -> Decoder s Word64 -> Decoder s UTCTime
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Word64
    forall s. Decoder s Word64
    decodeWord64
                TokenType
    TypeNInt    -> Int -> UTCTime
    forall a. Integral a => a -> UTCTime
    utcFromIntegral (Int -> UTCTime) -> Decoder s Int -> Decoder s UTCTime
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Int
    forall s. Decoder s Int
    decodeInt
                TokenType
    TypeNInt64  -> Int64 -> UTCTime
    forall a. Integral a => a -> UTCTime
    utcFromIntegral (Int64 -> UTCTime) -> Decoder s Int64 -> Decoder s UTCTime
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Int64
    forall s. Decoder s Int64
    decodeInt64
                TokenType
    TypeInteger -> Integer -> UTCTime
    forall a. Integral a => a -> UTCTime
    utcFromIntegral (Integer -> UTCTime) -> Decoder s Integer -> Decoder s UTCTime
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Integer
    forall s. Decoder s Integer
    decodeInteger
                TokenType
    TypeFloat16 -> Float -> UTCTime
    forall a. Real a => a -> UTCTime
    utcFromReal (Float -> UTCTime) -> Decoder s Float -> Decoder s UTCTime
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Float
    forall s. Decoder s Float
    decodeFloat
                TokenType
    TypeFloat32 -> Float -> UTCTime
    forall a. Real a => a -> UTCTime
    utcFromReal (Float -> UTCTime) -> Decoder s Float -> Decoder s UTCTime
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Float
    forall s. Decoder s Float
    decodeFloat
                TokenType
    TypeFloat64 -> Double -> UTCTime
    forall a. Real a => a -> UTCTime
    utcFromReal (Double -> UTCTime) -> Decoder s Double -> Decoder s UTCTime
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s Double
    forall s. Decoder s Double
    decodeDouble
                TokenType
    _ -> String -> Decoder s UTCTime
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "Expected numeric type following tag 1 (epoch offset)"

            -- Extended time
            Word
    1000 -> do
              len <- Decoder s Int
    forall s. Decoder s Int
    decodeMapLen
              when (len /= 2) $ fail "Expected list of length two (UTCTime)"

              k0 <- decodeInt
              when (k0 /= 1) $ fail "Expected key 1 in extended time"
              v0 <- decodeInt64

              k1 <- decodeInt
              when (k1 /= (-12)) $ fail "Expected key -12 in extended time"
              v1 <- decodeWord64
              let psecs :: Pico
                  psecs = Word64 -> Pico
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Word64
    v1 Pico -> Pico -> Pico
    forall a. Fractional a => a -> a -> a
    / Pico
    1000000000000

                  dt :: POSIXTime
                  dt = Int64 -> POSIXTime
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Int64
    v0 POSIXTime -> POSIXTime -> POSIXTime
    forall a. Num a => a -> a -> a
    + Pico -> POSIXTime
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Pico
    psecs
              return $! forceUTCTime (posixSecondsToUTCTime dt)

            Word
    _ -> String -> Decoder s UTCTime
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "Expected timestamp (tag 0, 1, or 40)"

    epoch :: UTCTime
    epoch :: UTCTime
    epoch = Day -> DiffTime -> UTCTime
    UTCTime (Integer -> Int -> Int -> Day
    fromGregorian Integer
    1970 Int
    1 Int
    1) DiffTime
    0

    {-# INLINE utcFromIntegral #-}
    utcFromIntegral :: Integral a => a -> UTCTime
    utcFromIntegral :: forall a. Integral a => a -> UTCTime
    utcFromIntegral a
    i = POSIXTime -> UTCTime -> UTCTime
    addUTCTime (a -> POSIXTime
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral a
    i) UTCTime
    epoch

    {-# INLINE utcFromReal #-}
    utcFromReal :: Real a => a -> UTCTime
    utcFromReal :: forall a. Real a => a -> UTCTime
    utcFromReal a
    f = POSIXTime -> UTCTime -> UTCTime
    addUTCTime (Rational -> POSIXTime
    forall a. Fractional a => Rational -> a
    fromRational (a -> Rational
    forall a. Real a => a -> Rational
    toRational a
    f)) UTCTime
    epoch

    -- | @'UTCTime'@ parsing, from a regular @'String'@.
    parseUTCrfc3339  :: String -> Maybe UTCTime
    #if MIN_VERSION_time(1,5,0)
    parseUTCrfc3339 :: String -> Maybe UTCTime
    parseUTCrfc3339  = Bool -> TimeLocale -> String -> String -> Maybe UTCTime
    forall (m :: * -> *) t.
    (MonadFail m, ParseTime t) =>
    Bool -> TimeLocale -> String -> String -> m t
    parseTimeM Bool
    False TimeLocale
    defaultTimeLocale String
    "%Y-%m-%dT%H:%M:%S%Q%Z"
    #else
    parseUTCrfc3339  = parseTime        defaultTimeLocale "%Y-%m-%dT%H:%M:%S%Q%Z"
    #endif

    -- | Force the unnecessarily lazy @'UTCTime'@ representation.
    forceUTCTime :: UTCTime -> UTCTime
    forceUTCTime :: UTCTime -> UTCTime
    forceUTCTime t :: UTCTime
    t@(UTCTime !Day
    _day !DiffTime
    _daytime) = UTCTime
    t

    --------------------------------------------------------------------------------
    -- Generic instances

    -- Factored into two classes because this makes GHC optimize the
    -- instances faster. This doesn't matter for builds of binary, but it
    -- matters a lot for end-users who write 'instance Binary T'. See
    -- also: https://ghc.haskell.org/trac/ghc/ticket/9630

    -- | @since 0.2.0.0
    class GSerialiseEncode f where
        -- | @since 0.2.0.0
        gencode  :: f a -> Encoding

    -- | @since 0.2.0.0
    class GSerialiseDecode f where
        -- | @since 0.2.0.0
        gdecode  :: Decoder s (f a)

    -- | @since 0.2.0.0
    instance GSerialiseEncode V1 where
        -- Data types without constructors are still serialised as null value
        gencode :: forall (a :: k). V1 a -> Encoding
    gencode V1 a
    _ = Encoding
    encodeNull

    -- | @since 0.2.0.0
    instance GSerialiseDecode V1 where
        gdecode :: forall s (a :: k). Decoder s (V1 a)
    gdecode   = String -> V1 a
    forall a. HasCallStack => String -> a
    error String
    "V1 don't have contructors" V1 a -> Decoder s () -> Decoder s (V1 a)
    forall a b. a -> Decoder s b -> Decoder s a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Decoder s ()
    forall s. Decoder s ()
    decodeNull

    -- | @since 0.2.0.0
    instance GSerialiseEncode U1 where
        -- Constructors without fields are serialised as null value
        gencode :: forall (a :: k). U1 a -> Encoding
    gencode U1 a
    _ = Word -> Encoding
    encodeListLen Word
    1 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    0

    -- | @since 0.2.0.0
    instance GSerialiseDecode U1 where
        gdecode :: forall s (a :: k). Decoder s (U1 a)
    gdecode   = do
          n <- Decoder s Int
    forall s. Decoder s Int
    decodeListLen
          when (n /= 1) $ fail "expect list of length 1"
          tag <- decodeWord
          when (tag /= 0) $ fail "unexpected tag. Expect 0"
          return U1

    -- | @since 0.2.0.0
    instance GSerialiseEncode a => GSerialiseEncode (M1 i c a) where
        -- Metadata (constructor name, etc) is skipped
        gencode :: forall (a :: k). M1 i c a a -> Encoding
    gencode = a a -> Encoding
    forall (a :: k). a a -> Encoding
    forall {k} (f :: k -> *) (a :: k).
    GSerialiseEncode f =>
    f a -> Encoding
    gencode (a a -> Encoding) -> (M1 i c a a -> a a) -> M1 i c a a -> Encoding
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . M1 i c a a -> a a
    forall k i (c :: Meta) (f :: k -> *) (p :: k). M1 i c f p -> f p
    unM1

    -- | @since 0.2.0.0
    instance GSerialiseDecode a => GSerialiseDecode (M1 i c a) where
        gdecode :: forall s (a :: k). Decoder s (M1 i c a a)
    gdecode = a a -> M1 i c a a
    forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
    M1 (a a -> M1 i c a a) -> Decoder s (a a) -> Decoder s (M1 i c a a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s (a a)
    forall s (a :: k). Decoder s (a a)
    forall {k} (f :: k -> *) s (a :: k).
    GSerialiseDecode f =>
    Decoder s (f a)
    gdecode

    -- | @since 0.2.0.0
    instance Serialise a => GSerialiseEncode (K1 i a) where
        -- Constructor field (Could only appear in one-field & one-constructor
        -- data types). In all other cases we go through GSerialise{Sum,Prod}
        gencode :: forall (a :: k). K1 i a a -> Encoding
    gencode (K1 a
    a) = Word -> Encoding
    encodeListLen Word
    2
                      Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    0
                      Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    a

    -- | @since 0.2.0.0
    instance Serialise a => GSerialiseDecode (K1 i a) where
        gdecode :: forall s (a :: k). Decoder s (K1 i a a)
    gdecode = do
          n <- Decoder s Int
    forall s. Decoder s Int
    decodeListLen
          when (n /= 2) $
            fail "expect list of length 2"
          tag <- decodeWord
          when (tag /= 0) $
            fail "unexpected tag. Expects 0"
          K1 <$> decode

    -- | @since 0.2.0.0
    instance (GSerialiseProd f, GSerialiseProd g) => GSerialiseEncode (f :*: g) where
        -- Products are serialised as N-tuples with 0 constructor tag
        gencode :: forall (a :: k). (:*:) f g a -> Encoding
    gencode (f a
    f :*: g a
    g)
            = Word -> Encoding
    encodeListLen (Proxy (f :*: g) -> Word
    forall {k} (f :: k -> *). GSerialiseProd f => Proxy f -> Word
    nFields (Proxy (f :*: g)
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy (f :*: g)) Word -> Word -> Word
    forall a. Num a => a -> a -> a
    + Word
    1)
           Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    encodeWord Word
    0
           Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> f a -> Encoding
    forall (a :: k). f a -> Encoding
    forall {k} (f :: k -> *) (a :: k).
    GSerialiseProd f =>
    f a -> Encoding
    encodeSeq f a
    f
           Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> g a -> Encoding
    forall (a :: k). g a -> Encoding
    forall {k} (f :: k -> *) (a :: k).
    GSerialiseProd f =>
    f a -> Encoding
    encodeSeq g a
    g

    -- | @since 0.2.0.0
    instance (GSerialiseProd f, GSerialiseProd g) => GSerialiseDecode (f :*: g) where
        gdecode :: forall s (a :: k). Decoder s ((:*:) f g a)
    gdecode = do
          let nF :: Word
    nF = Proxy (f :*: g) -> Word
    forall {k} (f :: k -> *). GSerialiseProd f => Proxy f -> Word
    nFields (Proxy (f :*: g)
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy (f :*: g))
          n <- Decoder s Int
    forall s. Decoder s Int
    decodeListLen
          -- TODO FIXME: signedness of list length
          when (fromIntegral n /= nF + 1) $
            fail $ "Wrong number of fields: expected="++show (nF+1)++" got="++show n
          tag <- decodeWord
          when (tag /= 0) $
            fail $ "unexpect tag (expect 0)"
          !f <- gdecodeSeq
          !g <- gdecodeSeq
          return $ f :*: g

    -- | @since 0.2.0.0
    instance (GSerialiseSum f, GSerialiseSum g) => GSerialiseEncode (f :+: g) where
        -- Sum types are serialised as N-tuples and first element is
        -- constructor tag
        gencode :: forall (a :: k). (:+:) f g a -> Encoding
    gencode (:+:) f g a
    a = Word -> Encoding
    encodeListLen ((:+:) f g a -> Word
    forall (a :: k). (:+:) f g a -> Word
    forall {k} (f :: k -> *) (a :: k). GSerialiseSum f => f a -> Word
    numOfFields (:+:) f g a
    a Word -> Word -> Word
    forall a. Num a => a -> a -> a
    + Word
    1)
                 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> Word -> Encoding
    forall a. Serialise a => a -> Encoding
    encode ((:+:) f g a -> Word
    forall (a :: k). (:+:) f g a -> Word
    forall {k} (f :: k -> *) (a :: k). GSerialiseSum f => f a -> Word
    conNumber (:+:) f g a
    a)
                 Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> (:+:) f g a -> Encoding
    forall (a :: k). (:+:) f g a -> Encoding
    forall {k} (f :: k -> *) (a :: k).
    GSerialiseSum f =>
    f a -> Encoding
    encodeSum (:+:) f g a
    a

    -- | @since 0.2.0.0
    instance (GSerialiseSum f, GSerialiseSum g) => GSerialiseDecode (f :+: g) where
        gdecode :: forall s (a :: k). Decoder s ((:+:) f g a)
    gdecode = do
            n <- Decoder s Int
    forall s. Decoder s Int
    decodeListLen
            -- TODO FIXME: Again signedness
            when (n == 0) $
              fail "Empty list encountered for sum type"
            nCon  <- decodeWord
            trueN <- fieldsForCon (Proxy :: Proxy (f :+: g)) nCon
            when (n-1 /= fromIntegral trueN ) $
              fail $ "Number of fields mismatch: expected="++show trueN++" got="++show n
            decodeSum nCon

    -- | Serialization of product types
    class GSerialiseProd f where
        -- | Number of fields in product type
        nFields   :: Proxy f -> Word
        -- | Encode fields sequentially without writing header
        encodeSeq :: f a -> Encoding
        -- | Decode fields sequentially without reading header
        gdecodeSeq :: Decoder s (f a)

    -- | @since 0.2.0.0
    instance (GSerialiseProd f, GSerialiseProd g) => GSerialiseProd (f :*: g) where
        nFields :: Proxy (f :*: g) -> Word
    nFields Proxy (f :*: g)
    _ = Proxy f -> Word
    forall {k} (f :: k -> *). GSerialiseProd f => Proxy f -> Word
    nFields (Proxy f
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy f) Word -> Word -> Word
    forall a. Num a => a -> a -> a
    + Proxy g -> Word
    forall {k} (f :: k -> *). GSerialiseProd f => Proxy f -> Word
    nFields (Proxy g
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy g)
        encodeSeq :: forall (a :: k). (:*:) f g a -> Encoding
    encodeSeq (f a
    f :*: g a
    g) = f a -> Encoding
    forall (a :: k). f a -> Encoding
    forall {k} (f :: k -> *) (a :: k).
    GSerialiseProd f =>
    f a -> Encoding
    encodeSeq f a
    f Encoding -> Encoding -> Encoding
    forall a. Semigroup a => a -> a -> a
    <> g a -> Encoding
    forall (a :: k). g a -> Encoding
    forall {k} (f :: k -> *) (a :: k).
    GSerialiseProd f =>
    f a -> Encoding
    encodeSeq g a
    g
        gdecodeSeq :: forall s (a :: k). Decoder s ((:*:) f g a)
    gdecodeSeq = do !f <- Decoder s (f a)
    forall s (a :: k). Decoder s (f a)
    forall {k} (f :: k -> *) s (a :: k).
    GSerialiseProd f =>
    Decoder s (f a)
    gdecodeSeq
                        !g <- gdecodeSeq
                        return (f :*: g)

    -- | @since 0.2.0.0
    instance GSerialiseProd U1 where
        -- N.B. Could only be reached when one of constructors in sum type
        --      don't have parameters
        nFields :: Proxy U1 -> Word
    nFields   Proxy U1
    _ = Word
    0
        encodeSeq :: forall (a :: k). U1 a -> Encoding
    encodeSeq U1 a
    _ = Encoding
    forall a. Monoid a => a
    mempty
        gdecodeSeq :: forall s (a :: k). Decoder s (U1 a)
    gdecodeSeq  = U1 a -> Decoder s (U1 a)
    forall a. a -> Decoder s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return U1 a
    forall k (p :: k). U1 p
    U1

    -- | @since 0.2.0.0
    instance (Serialise a) => GSerialiseProd (K1 i a) where
        -- Ordinary field
        nFields :: Proxy (K1 i a) -> Word
    nFields    Proxy (K1 i a)
    _     = Word
    1
        encodeSeq :: forall (a :: k). K1 i a a -> Encoding
    encodeSeq (K1 a
    f) = a -> Encoding
    forall a. Serialise a => a -> Encoding
    encode a
    f
        gdecodeSeq :: forall s (a :: k). Decoder s (K1 i a a)
    gdecodeSeq       = a -> K1 i a a
    forall k i c (p :: k). c -> K1 i c p
    K1 (a -> K1 i a a) -> Decoder s a -> Decoder s (K1 i a a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s a
    forall s. Decoder s a
    forall a s. Serialise a => Decoder s a
    decode

    -- | @since 0.2.0.0
    instance (i ~ S, GSerialiseProd f) => GSerialiseProd (M1 i c f) where
        -- We skip metadata
        nFields :: Proxy (M1 i c f) -> Word
    nFields     Proxy (M1 i c f)
    _     = Word
    1
        encodeSeq :: forall (a :: k). M1 i c f a -> Encoding
    encodeSeq  (M1 f a
    f) = f a -> Encoding
    forall (a :: k). f a -> Encoding
    forall {k} (f :: k -> *) (a :: k).
    GSerialiseProd f =>
    f a -> Encoding
    encodeSeq f a
    f
        gdecodeSeq :: forall s (a :: k). Decoder s (M1 i c f a)
    gdecodeSeq        = f a -> M1 i c f a
    forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
    M1 (f a -> M1 i c f a) -> Decoder s (f a) -> Decoder s (M1 i c f a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s (f a)
    forall s (a :: k). Decoder s (f a)
    forall {k} (f :: k -> *) s (a :: k).
    GSerialiseProd f =>
    Decoder s (f a)
    gdecodeSeq

    -- | Serialization of sum types
    --
    -- @since 0.2.0.0
    class GSerialiseSum f where
        -- | Number of constructor of given value
        conNumber   :: f a -> Word
        -- | Number of fields of given value
        numOfFields :: f a -> Word
        -- | Encode field
        encodeSum   :: f a  -> Encoding

        -- | Decode field
        decodeSum     :: Word -> Decoder s (f a)
        -- | Number of constructors
        nConstructors :: Proxy f -> Word
        -- | Number of fields for given constructor number
        fieldsForCon  :: Proxy f -> Word -> Decoder s Word

    -- | @since 0.2.0.0
    instance (GSerialiseSum f, GSerialiseSum g) => GSerialiseSum (f :+: g) where
        conNumber :: forall (a :: k). (:+:) f g a -> Word
    conNumber (:+:) f g a
    x = case (:+:) f g a
    x of
          L1 f a
    f -> f a -> Word
    forall (a :: k). f a -> Word
    forall {k} (f :: k -> *) (a :: k). GSerialiseSum f => f a -> Word
    conNumber f a
    f
          R1 g a
    g -> g a -> Word
    forall (a :: k). g a -> Word
    forall {k} (f :: k -> *) (a :: k). GSerialiseSum f => f a -> Word
    conNumber g a
    g Word -> Word -> Word
    forall a. Num a => a -> a -> a
    + Proxy f -> Word
    forall {k} (f :: k -> *). GSerialiseSum f => Proxy f -> Word
    nConstructors (Proxy f
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy f)
        numOfFields :: forall (a :: k). (:+:) f g a -> Word
    numOfFields (:+:) f g a
    x = case (:+:) f g a
    x of
          L1 f a
    f -> f a -> Word
    forall (a :: k). f a -> Word
    forall {k} (f :: k -> *) (a :: k). GSerialiseSum f => f a -> Word
    numOfFields f a
    f
          R1 g a
    g -> g a -> Word
    forall (a :: k). g a -> Word
    forall {k} (f :: k -> *) (a :: k). GSerialiseSum f => f a -> Word
    numOfFields g a
    g
        encodeSum :: forall (a :: k). (:+:) f g a -> Encoding
    encodeSum (:+:) f g a
    x = case (:+:) f g a
    x of
          L1 f a
    f -> f a -> Encoding
    forall (a :: k). f a -> Encoding
    forall {k} (f :: k -> *) (a :: k).
    GSerialiseSum f =>
    f a -> Encoding
    encodeSum f a
    f
          R1 g a
    g -> g a -> Encoding
    forall (a :: k). g a -> Encoding
    forall {k} (f :: k -> *) (a :: k).
    GSerialiseSum f =>
    f a -> Encoding
    encodeSum g a
    g

        nConstructors :: Proxy (f :+: g) -> Word
    nConstructors Proxy (f :+: g)
    _ = Proxy f -> Word
    forall {k} (f :: k -> *). GSerialiseSum f => Proxy f -> Word
    nConstructors (Proxy f
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy f)
                        Word -> Word -> Word
    forall a. Num a => a -> a -> a
    + Proxy g -> Word
    forall {k} (f :: k -> *). GSerialiseSum f => Proxy f -> Word
    nConstructors (Proxy g
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy g)

        fieldsForCon :: forall s. Proxy (f :+: g) -> Word -> Decoder s Word
    fieldsForCon Proxy (f :+: g)
    _ Word
    n | Word
    n Word -> Word -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word
    nL    = Proxy f -> Word -> Decoder s Word
    forall s. Proxy f -> Word -> Decoder s Word
    forall {k} (f :: k -> *) s.
    GSerialiseSum f =>
    Proxy f -> Word -> Decoder s Word
    fieldsForCon (Proxy f
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy f) Word
    n
                         | Bool
    otherwise = Proxy g -> Word -> Decoder s Word
    forall s. Proxy g -> Word -> Decoder s Word
    forall {k} (f :: k -> *) s.
    GSerialiseSum f =>
    Proxy f -> Word -> Decoder s Word
    fieldsForCon (Proxy g
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy g) (Word
    n Word -> Word -> Word
    forall a. Num a => a -> a -> a
    - Word
    nL)
          where
            nL :: Word
    nL = Proxy f -> Word
    forall {k} (f :: k -> *). GSerialiseSum f => Proxy f -> Word
    nConstructors (Proxy f
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy f)

        decodeSum :: forall s (a :: k). Word -> Decoder s ((:+:) f g a)
    decodeSum Word
    nCon | Word
    nCon Word -> Word -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word
    nL = f a -> (:+:) f g a
    forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
    L1 (f a -> (:+:) f g a) -> Decoder s (f a) -> Decoder s ((:+:) f g a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Word -> Decoder s (f a)
    forall s (a :: k). Word -> Decoder s (f a)
    forall {k} (f :: k -> *) s (a :: k).
    GSerialiseSum f =>
    Word -> Decoder s (f a)
    decodeSum Word
    nCon
                       | Bool
    otherwise = g a -> (:+:) f g a
    forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
    R1 (g a -> (:+:) f g a) -> Decoder s (g a) -> Decoder s ((:+:) f g a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Word -> Decoder s (g a)
    forall s (a :: k). Word -> Decoder s (g a)
    forall {k} (f :: k -> *) s (a :: k).
    GSerialiseSum f =>
    Word -> Decoder s (f a)
    decodeSum (Word
    nCon Word -> Word -> Word
    forall a. Num a => a -> a -> a
    - Word
    nL)
          where
            nL :: Word
    nL = Proxy f -> Word
    forall {k} (f :: k -> *). GSerialiseSum f => Proxy f -> Word
    nConstructors (Proxy f
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy f)

    -- | @since 0.2.0.0
    instance (i ~ C, GSerialiseProd f) => GSerialiseSum (M1 i c f) where
        conNumber :: forall (a :: k). M1 i c f a -> Word
    conNumber    M1 i c f a
    _     = Word
    0
        numOfFields :: forall (a :: k). M1 i c f a -> Word
    numOfFields  M1 i c f a
    _     = Proxy f -> Word
    forall {k} (f :: k -> *). GSerialiseProd f => Proxy f -> Word
    nFields (Proxy f
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy f)
        encodeSum :: forall (a :: k). M1 i c f a -> Encoding
    encodeSum   (M1 f a
    f) = f a -> Encoding
    forall (a :: k). f a -> Encoding
    forall {k} (f :: k -> *) (a :: k).
    GSerialiseProd f =>
    f a -> Encoding
    encodeSeq f a
    f

        nConstructors :: Proxy (M1 i c f) -> Word
    nConstructors  Proxy (M1 i c f)
    _ = Word
    1
        fieldsForCon :: forall s. Proxy (M1 i c f) -> Word -> Decoder s Word
    fieldsForCon Proxy (M1 i c f)
    _ Word
    0 = Word -> Decoder s Word
    forall a. a -> Decoder s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word -> Decoder s Word) -> Word -> Decoder s Word
    forall a b. (a -> b) -> a -> b
    $ Proxy f -> Word
    forall {k} (f :: k -> *). GSerialiseProd f => Proxy f -> Word
    nFields (Proxy f
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy f)
        fieldsForCon Proxy (M1 i c f)
    _ Word
    _ = String -> Decoder s Word
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "Bad constructor number"
        decodeSum :: forall s (a :: k). Word -> Decoder s (M1 i c f a)
    decodeSum      Word
    0 = f a -> M1 i c f a
    forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
    M1 (f a -> M1 i c f a) -> Decoder s (f a) -> Decoder s (M1 i c f a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Decoder s (f a)
    forall s (a :: k). Decoder s (f a)
    forall {k} (f :: k -> *) s (a :: k).
    GSerialiseProd f =>
    Decoder s (f a)
    gdecodeSeq
        decodeSum      Word
    _ = String -> Decoder s (M1 i c f a)
    forall a. String -> Decoder s a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "bad constructor number"