Flat Bool Source #	One bit is plenty for a Bool. `>>>` `test False`(True,1,"0") `>>>` `test True`(True,1,"1")
Instance details Defined in Flat.Instances.Base Methods encode :: Bool -> Encoding Source # decode :: Get Bool Source # size :: Bool -> NumBits -> NumBits Source #
Flat Char Source #	Char's are mapped to Word32 and then encoded. For ascii characters, the encoding is standard ascii. `>>>` `test 'a'`(True,8,"01100001") For unicode characters, the encoding is non standard. `>>>` `test 'È'`(True,16,"11001000 00000001") `>>>` `test '不'`(True,24,"10001101 10011100 00000001") `>>>` `test "\x1F600"`(True,26,"11000000 01110110 00000011 10")
Instance details Defined in Flat.Instances.Base Methods encode :: Char -> Encoding Source # decode :: Get Char Source # size :: Char -> NumBits -> NumBits Source #
Flat Double Source #	Doubles are encoded as standard IEEE binary64 values: IEEE_754_binary64 ≡ IEEE_754_binary64 {sign :: Sign, exponent :: MostSignificantFirst Bits11, fraction :: MostSignificantFirst Bits52}
Instance details Defined in Flat.Instances.Base Methods encode :: Double -> Encoding Source # decode :: Get Double Source # size :: Double -> NumBits -> NumBits Source #
Flat Float Source #	Floats are encoded as standard IEEE binary32 values: IEEE_754_binary32 ≡ IEEE_754_binary32 {sign :: Sign, exponent :: MostSignificantFirst Bits8, fraction :: MostSignificantFirst Bits23} `>>>` `test (0::Float)`(True,32,"00000000 00000000 00000000 00000000") `>>>` `test (1.4012984643E-45::Float)`(True,32,"00000000 00000000 00000000 00000001") `>>>` `test (1.1754942107E-38::Float)`(True,32,"00000000 01111111 11111111 11111111")
Instance details Defined in Flat.Instances.Base Methods encode :: Float -> Encoding Source # decode :: Get Float Source # size :: Float -> NumBits -> NumBits Source #
Flat Int Source #	Integer, Int, Int16, Int32 and Int64 are defined as the ZigZag encoded version of the equivalent unsigned Word: Int ≡ Int (ZigZag Word) Int64 ≡ Int64 (ZigZag Word64) Int32 ≡ Int32 (ZigZag Word32) Int16 ≡ Int16 (ZigZag Word16) Int8 ≡ Int8 (ZigZag Word8) ZigZag a ≡ ZigZag a ZigZag encoding alternates between positive and negative numbers, so that numbers whose absolute value is small can be encoded efficiently: `>>>` `test (0::Int)`(True,8,"00000000") `>>>` `test (-1::Int)`(True,8,"00000001") `>>>` `test (1::Int)`(True,8,"00000010") `>>>` `test (-2::Int)`(True,8,"00000011") `>>>` `test (2::Int)`(True,8,"00000100")
Instance details Defined in Flat.Instances.Base Methods encode :: Int -> Encoding Source # decode :: Get Int Source # size :: Int -> NumBits -> NumBits Source #
Flat Int8 Source #	`>>>` `test (0::Int8)`(True,8,"00000000") `>>>` `test (127::Int8)`(True,8,"11111110") `>>>` `test (-128::Int8)`(True,8,"11111111")
Instance details Defined in Flat.Instances.Base Methods encode :: Int8 -> Encoding Source # decode :: Get Int8 Source # size :: Int8 -> NumBits -> NumBits Source #
Flat Int16 Source #	`>>>` `test (0::Int16)`(True,8,"00000000") `>>>` `test (1::Int16)`(True,8,"00000010") `>>>` `test (-1::Int16)`(True,8,"00000001") `>>>` `test (minBound::Int16)`(True,24,"11111111 11111111 00000011") equivalent to 0b1111111111111111 `>>>` `test (maxBound::Int16)`(True,24,"11111110 11111111 00000011") equivalent to 0b1111111111111110
Instance details Defined in Flat.Instances.Base Methods encode :: Int16 -> Encoding Source # decode :: Get Int16 Source # size :: Int16 -> NumBits -> NumBits Source #
Flat Int32 Source #	`>>>` `test (0::Int32)`(True,8,"00000000") `>>>` `test (minBound::Int32)`(True,40,"11111111 11111111 11111111 11111111 00001111") `>>>` `test (maxBound::Int32)`(True,40,"11111110 11111111 11111111 11111111 00001111")
Instance details Defined in Flat.Instances.Base Methods encode :: Int32 -> Encoding Source # decode :: Get Int32 Source # size :: Int32 -> NumBits -> NumBits Source #
Flat Int64 Source #	`>>>` `test (0::Int64)`(True,8,"00000000") `>>>` `test (minBound::Int64)`(True,80,"11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 00000001") `>>>` `test (maxBound::Int64)`(True,80,"11111110 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 00000001")
Instance details Defined in Flat.Instances.Base Methods encode :: Int64 -> Encoding Source # decode :: Get Int64 Source # size :: Int64 -> NumBits -> NumBits Source #
Flat Integer Source #	Integers are encoded just as the fixed size Ints. `>>>` `test (0::Integer)`(True,8,"00000000") `>>>` `test (-1::Integer)`(True,8,"00000001") `>>>` `test (1::Integer)`(True,8,"00000010") `>>>` `test (-(2^4)::Integer)`(True,8,"00011111") `>>>` `test (2^4::Integer)`(True,8,"00100000") `>>>` `test (-(2^120)::Integer)`(True,144,"11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 00000011") `>>>` `test (2^120::Integer)`(True,144,"10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 00000100")
Instance details Defined in Flat.Instances.Base Methods encode :: Integer -> Encoding Source # decode :: Get Integer Source # size :: Integer -> NumBits -> NumBits Source #
Flat Natural Source #	Naturals are encoded just as the fixed size Words. `>>>` `test (0::Natural)`(True,8,"00000000") `>>>` `test (2^120::Natural)`(True,144,"10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 00000010")
Instance details Defined in Flat.Instances.Base Methods encode :: Natural -> Encoding Source # decode :: Get Natural Source # size :: Natural -> NumBits -> NumBits Source #
Flat Word Source #	Natural, Word, Word16, Word32 and Word64 are encoded as a non empty list of 7 bits chunks (least significant chunk first and most significant bit first in every chunk). Words are always encoded in a whole number of bytes, as every chunk is 8 bits long (1 bit for the List constructor, plus 7 bits for the value). The actual definition is: Word64 ≡ Word64 Word Word32 ≡ Word32 Word Word16 ≡ Word16 Word Word ≡ Word (LeastSignificantFirst (NonEmptyList (MostSignificantFirst Word7))) LeastSignificantFirst a ≡ LeastSignificantFirst a NonEmptyList a ≡ Elem a \| Cons a (NonEmptyList a) MostSignificantFirst a ≡ MostSignificantFirst a Word7 ≡ V0 \| V1 \| V2 ... \| V127 Values between as 0 and 127 fit in a single byte. 127 (0b1111111) is represented as Elem V127 and encoded as: Elem=0 127=1111111 `>>>` `test (127::Word)`(True,8,"01111111") 254 (0b11111110) is represented as Cons V126 (Elem V1) (254=128+126) and encoded as: Cons=1 V126=1111110 (Elem=0 V1=0000001): `>>>` `test (254::Word)`(True,16,"11111110 00000001") Another example, 32768 (Ob1000000000000000 = 0000010 0000000 0000000): `>>>` `test (32768::Word32)`(True,24,"10000000 10000000 00000010") As this is a variable length encoding, values are encoded in the same way, whatever their type: `>>>` `all (test (3::Word) ==) [test (3::Word16),test (3::Word32),test (3::Word64)]`True
Instance details Defined in Flat.Instances.Base Methods encode :: Word -> Encoding Source # decode :: Get Word Source # size :: Word -> NumBits -> NumBits Source #
Flat Word8 Source #	Word8 always take 8 bits. `>>>` `test (0::Word8)`(True,8,"00000000") `>>>` `test (255::Word8)`(True,8,"11111111")
Instance details Defined in Flat.Instances.Base Methods encode :: Word8 -> Encoding Source # decode :: Get Word8 Source # size :: Word8 -> NumBits -> NumBits Source #
Flat Word16 Source #
Instance details Defined in Flat.Instances.Base Methods encode :: Word16 -> Encoding Source # decode :: Get Word16 Source # size :: Word16 -> NumBits -> NumBits Source #
Flat Word32 Source #
Instance details Defined in Flat.Instances.Base Methods encode :: Word32 -> Encoding Source # decode :: Get Word32 Source # size :: Word32 -> NumBits -> NumBits Source #
Flat Word64 Source #
Instance details Defined in Flat.Instances.Base Methods encode :: Word64 -> Encoding Source # decode :: Get Word64 Source # size :: Word64 -> NumBits -> NumBits Source #
Flat () Source #	`()` , as all data types with a single constructor, has a zero-length encoding. `>>>` `test ()`(True,0,"")
Instance details Defined in Flat.Instances.Base Methods encode :: () -> Encoding Source # decode :: Get () Source # size :: () -> NumBits -> NumBits Source #
Flat All Source #	Since: 0.4.4
Instance details Defined in Flat.Instances.Base Methods encode :: All -> Encoding Source # decode :: Get All Source # size :: All -> NumBits -> NumBits Source #
Flat Any Source #	Since: 0.4.4
Instance details Defined in Flat.Instances.Base Methods encode :: Any -> Encoding Source # decode :: Get Any Source # size :: Any -> NumBits -> NumBits Source #
Flat ShortByteString Source #	`>>>` `tst ((False,True,False,SBS.pack [11,22,33]))`(True,51,[65,3,11,22,33,0])
Instance details Defined in Flat.Instances.ByteString Methods encode :: ShortByteString -> Encoding Source # decode :: Get ShortByteString Source # size :: ShortByteString -> NumBits -> NumBits Source #
Flat ByteString Source #	`>>>` `tst ((False,True,False,L.pack [11,22,33]))`(True,51,[65,3,11,22,33,0])
Instance details Defined in Flat.Instances.ByteString Methods encode :: ByteString -> Encoding Source # decode :: Get ByteString Source # size :: ByteString -> NumBits -> NumBits Source #
Flat ByteString Source #	ByteString, ByteString.Lazy and ByteString.Short are all encoded as Prealigned Arrays: PreAligned a ≡ PreAligned {preFiller :: Filler, preValue :: a} Filler ≡ FillerBit Filler \| FillerEnd Array v = A0 \| A1 v (Array v) \| A2 v v (Array v) ... \| A255 ... (Array v) That's to say as a byte-aligned sequence of blocks of up to 255 elements, with every block preceded by the count of the elements in the block and a final 0-length block. `>>>` `tst (B.pack [11,22,33])`(True,48,[1,3,11,22,33,0]) where: 1= PreAlignment (takes a byte if we are already on a byte boundary) 3= Number of bytes in ByteString 11,22,33= Bytes 0= End of Array `>>>` `tst (B.pack [])`(True,16,[1,0]) Pre-alignment ensures that a ByteString always starts at a byte boundary: `>>>` `tst ((False,True,False,B.pack [11,22,33]))`(True,51,[65,3,11,22,33,0]) All ByteStrings are encoded in the same way: `>>>` `all (tst (B.pack [55]) ==) [tst (L.pack [55]),tst (SBS.pack [55])]`True
Instance details Defined in Flat.Instances.ByteString Methods encode :: ByteString -> Encoding Source # decode :: Get ByteString Source # size :: ByteString -> NumBits -> NumBits Source #
Flat Text Source #	Text (and Data.Text.Lazy) is encoded as a byte aligned array of bytes corresponding to its UTF8 encoding. `>>>` `tst $ T.pack ""`(True,16,[1,0]) `>>>` `tst $ T.pack "aaa"`(True,120,[1,3,97,97,97,0]) `>>>` `tst $ T.pack "¢¢¢"`(True,120,[1,6,194,162,194,162,194,162,0]) `>>>` `tst $ T.pack "日日日"`(True,120,[1,9,230,151,165,230,151,165,230,151,165,0]) `>>>` `tst $ T.pack "𐍈𐍈𐍈"`(True,120,[1,12,240,144,141,136,240,144,141,136,240,144,141,136,0]) Strict and Lazy Text has the same encoding: `>>>` `tst (T.pack "abc") == tst (TL.pack "abc")`True
Instance details Defined in Flat.Instances.Text Methods encode :: Text -> Encoding Source # decode :: Get Text Source # size :: Text -> NumBits -> NumBits Source #
Flat Text Source #
Instance details Defined in Flat.Instances.Text Methods encode :: Text -> Encoding Source # decode :: Get Text Source # size :: Text -> NumBits -> NumBits Source #
Flat UTF16Text Source #
Instance details Defined in Flat.Instances.Text Methods encode :: UTF16Text -> Encoding Source # decode :: Get UTF16Text Source # size :: UTF16Text -> NumBits -> NumBits Source #
Flat UTF8Text Source #
Instance details Defined in Flat.Instances.Text Methods encode :: UTF8Text -> Encoding Source # decode :: Get UTF8Text Source # size :: UTF8Text -> NumBits -> NumBits Source #
Flat Filler Source #	Use a special encoding for the filler
Instance details Defined in Flat.Filler Methods encode :: Filler -> Encoding Source # decode :: Get Filler Source # size :: Filler -> NumBits -> NumBits Source #
Flat a => Flat [a] Source #	`>>>` `test ([]::[Bool])`(True,1,"0") `>>>` `test [False,False]`(True,5,"10100") This instance and other similar ones are declared as `OVERLAPPABLE` , because for better encoding/decoding performance it can be useful to declare instances of concrete types, such as `[Char]` (not provided out of the box).
Instance details Defined in Flat.Instances.Base Methods encode :: [a] -> Encoding Source # decode :: Get [a] Source # size :: [a] -> NumBits -> NumBits Source #
Flat a => Flat ( Maybe a) Source #	`>>>` `test (Nothing::Maybe Bool)`(True,1,"0") `>>>` `test (Just False::Maybe Bool)`(True,2,"10")
Instance details Defined in Flat.Instances.Base Methods encode :: Maybe a -> Encoding Source # decode :: Get ( Maybe a) Source # size :: Maybe a -> NumBits -> NumBits Source #
( Integral a, Flat a) => Flat ( Ratio a) Source #	Ratios are encoded as tuples of (numerator,denominator) `>>>` `test (3%4::Ratio Word8)`(True,16,"00000011 00000100")
Instance details Defined in Flat.Instances.Base Methods encode :: Ratio a -> Encoding Source # decode :: Get ( Ratio a) Source # size :: Ratio a -> NumBits -> NumBits Source #
Flat a => Flat ( Complex a) Source #	`>>>` `test (4 :+ 2 :: Complex Word8)`(True,16,"00000100 00000010")
Instance details Defined in Flat.Instances.Base Methods encode :: Complex a -> Encoding Source # decode :: Get ( Complex a) Source # size :: Complex a -> NumBits -> NumBits Source #
Flat a => Flat ( Min a) Source #	Since: 0.4.4
Instance details Defined in Flat.Instances.Base Methods encode :: Min a -> Encoding Source # decode :: Get ( Min a) Source # size :: Min a -> NumBits -> NumBits Source #
Flat a => Flat ( Max a) Source #	Since: 0.4.4
Instance details Defined in Flat.Instances.Base Methods encode :: Max a -> Encoding Source # decode :: Get ( Max a) Source # size :: Max a -> NumBits -> NumBits Source #
Flat a => Flat ( First a) Source #	Since: 0.4.4
Instance details Defined in Flat.Instances.Base Methods encode :: First a -> Encoding Source # decode :: Get ( First a) Source # size :: First a -> NumBits -> NumBits Source #
Flat a => Flat ( Last a) Source #	Since: 0.4.4
Instance details Defined in Flat.Instances.Base Methods encode :: Last a -> Encoding Source # decode :: Get ( Last a) Source # size :: Last a -> NumBits -> NumBits Source #
Flat a => Flat ( Identity a) Source #	Since: 0.4.4
Instance details Defined in Flat.Instances.Base Methods encode :: Identity a -> Encoding Source # decode :: Get ( Identity a) Source # size :: Identity a -> NumBits -> NumBits Source #
Flat a => Flat ( Dual a) Source #	Since: 0.4.4
Instance details Defined in Flat.Instances.Base Methods encode :: Dual a -> Encoding Source # decode :: Get ( Dual a) Source # size :: Dual a -> NumBits -> NumBits Source #
Flat a => Flat ( Sum a) Source #	Since: 0.4.4
Instance details Defined in Flat.Instances.Base Methods encode :: Sum a -> Encoding Source # decode :: Get ( Sum a) Source # size :: Sum a -> NumBits -> NumBits Source #
Flat a => Flat ( Product a) Source #	Since: 0.4.4
Instance details Defined in Flat.Instances.Base Methods encode :: Product a -> Encoding Source # decode :: Get ( Product a) Source # size :: Product a -> NumBits -> NumBits Source #
Flat a => Flat ( NonEmpty a) Source #	`>>>` `test (B.fromList [True])`(True,2,"10") `>>>` `test (B.fromList [False,False])`(True,4,"0100")
Instance details Defined in Flat.Instances.Base Methods encode :: NonEmpty a -> Encoding Source # decode :: Get ( NonEmpty a) Source # size :: NonEmpty a -> NumBits -> NumBits Source #
Flat a => Flat ( IntMap a) Source #	Maps are defined as a list of (Key,Value) tuples: Map = List (Key,Value) List a = Nil \| Cons a (List a) `>>>` `tst (Data.IntMap.empty :: IntMap ())`(True,1,[0]) `>>>` `asList Data.IntMap.fromList [(1,"a"),(2,"b")]`True
Instance details Defined in Flat.Instances.Containers Methods encode :: IntMap a -> Encoding Source # decode :: Get ( IntMap a) Source # size :: IntMap a -> NumBits -> NumBits Source #
Flat a => Flat ( Tree a) Source #	`>>>` `tst (Node (1::Word8) [Node 2 [Node 3 []], Node 4 []])`(True,39,[1,129,64,200,32])
Instance details Defined in Flat.Instances.Containers Methods encode :: Tree a -> Encoding Source # decode :: Get ( Tree a) Source # size :: Tree a -> NumBits -> NumBits Source #
Flat a => Flat ( Seq a) Source #	Data.Sequence.Seq is encoded as a list. `>>>` `asList Data.Sequence.fromList [3::Word8,4,7]`True In flat <0.4, it was encoded as an Array. If you want to restore the previous behaviour, use AsArray: `>>>` `tst $ AsArray (Data.Sequence.fromList [11::Word8,22,33])`(True,40,[3,11,22,33,0]) `>>>` `tst $ Data.Sequence.fromList [11::Word8,22,33]`(True,28,[133,197,164,32])
Instance details Defined in Flat.Instances.Containers Methods encode :: Seq a -> Encoding Source # decode :: Get ( Seq a) Source # size :: Seq a -> NumBits -> NumBits Source #
( Flat a, Ord a) => Flat ( Set a) Source #	Data.Set is encoded as a list `>>>` `asList Data.Set.fromList [3::Word8,4,7]`True
Instance details Defined in Flat.Instances.Containers Methods encode :: Set a -> Encoding Source # decode :: Get ( Set a) Source # size :: Set a -> NumBits -> NumBits Source #
Flat a => Flat ( DList a) Source #	`>>>` `test (Data.DList.fromList [7::Word,7])`(True,19,"10000011 11000001 110") `>>>` `let l = [7::Word,7] in flat (Data.DList.fromList l) == flat l`True
Instance details Defined in Flat.Instances.DList Methods encode :: DList a -> Encoding Source # decode :: Get ( DList a) Source # size :: DList a -> NumBits -> NumBits Source #
( Hashable a, Eq a, Flat a) => Flat ( HashSet a) Source #	`>>>` `test (Data.HashSet.fromList [1..3::Word])`(True,28,"10000000 11000000 10100000 0110")
Instance details Defined in Flat.Instances.Unordered Methods encode :: HashSet a -> Encoding Source # decode :: Get ( HashSet a) Source # size :: HashSet a -> NumBits -> NumBits Source #
( Unbox a, Flat a) => Flat ( Vector a) Source #
Instance details Defined in Flat.Instances.Vector Methods encode :: Vector a -> Encoding Source # decode :: Get ( Vector a) Source # size :: Vector a -> NumBits -> NumBits Source #
( Storable a, Flat a) => Flat ( Vector a) Source #
Instance details Defined in Flat.Instances.Vector Methods encode :: Vector a -> Encoding Source # decode :: Get ( Vector a) Source # size :: Vector a -> NumBits -> NumBits Source #
Flat a => Flat ( Vector a) Source #	Vectors are encoded as arrays. `>>>` `tst (V.fromList [11::Word8,22,33])`(True,40,[3,11,22,33,0]) All Vectors are encoded in the same way: `>>>` `let l = [11::Word8,22,33] in all (tst (V.fromList l) ==) [tst (U.fromList l),tst (S.fromList l)]`True
Instance details Defined in Flat.Instances.Vector Methods encode :: Vector a -> Encoding Source # decode :: Get ( Vector a) Source # size :: Vector a -> NumBits -> NumBits Source #
( IsMap map, Flat ( ContainerKey map), Flat ( MapValue map)) => Flat ( AsMap map) Source #
Instance details Defined in Flat.Instances.Mono Methods encode :: AsMap map -> Encoding Source # decode :: Get ( AsMap map) Source # size :: AsMap map -> NumBits -> NumBits Source #
( IsSet set, Flat ( Element set)) => Flat ( AsSet set) Source #
Instance details Defined in Flat.Instances.Mono Methods encode :: AsSet set -> Encoding Source # decode :: Get ( AsSet set) Source # size :: AsSet set -> NumBits -> NumBits Source #
( IsSequence l, Flat ( Element l)) => Flat ( AsList l) Source #
Instance details Defined in Flat.Instances.Mono Methods encode :: AsList l -> Encoding Source # decode :: Get ( AsList l) Source # size :: AsList l -> NumBits -> NumBits Source #
( IsSequence r, Flat ( Element r)) => Flat ( AsArray r) Source #
Instance details Defined in Flat.Instances.Mono Methods encode :: AsArray r -> Encoding Source # decode :: Get ( AsArray r) Source # size :: AsArray r -> NumBits -> NumBits Source #
Flat a => Flat ( PreAligned a) Source #
Instance details Defined in Flat.Filler Methods encode :: PreAligned a -> Encoding Source # decode :: Get ( PreAligned a) Source # size :: PreAligned a -> NumBits -> NumBits Source #
Flat a => Flat ( PostAligned a) Source #
Instance details Defined in Flat.Filler Methods encode :: PostAligned a -> Encoding Source # decode :: Get ( PostAligned a) Source # size :: PostAligned a -> NumBits -> NumBits Source #
Flat a => Flat ( Repr a) Source #
Instance details Defined in Flat.Repr Methods encode :: Repr a -> Encoding Source # decode :: Get ( Repr a) Source # size :: Repr a -> NumBits -> NumBits Source #
( Flat a, Flat b) => Flat ( Either a b) Source #	`>>>` `test (Left False::Either Bool ())`(True,2,"00") `>>>` `test (Right ()::Either Bool ())`(True,1,"1")
Instance details Defined in Flat.Instances.Base Methods encode :: Either a b -> Encoding Source # decode :: Get ( Either a b) Source # size :: Either a b -> NumBits -> NumBits Source #
( Flat a, Flat b) => Flat (a, b) Source #	Tuples are supported up to 7 elements. `>>>` `test (False,())`(True,1,"0") `>>>` `test ((),())`(True,0,"") "7 elements tuples ought to be enough for anybody" (Bill Gates - apocryphal) `>>>` `test (False,True,True,True,False,True,True)`(True,7,"0111011") tst (1::Int,"2","3","4","5","6","7","8") ...error
Instance details Defined in Flat.Instances.Base Methods encode :: (a, b) -> Encoding Source # decode :: Get (a, b) Source # size :: (a, b) -> NumBits -> NumBits Source #
( Flat i, Flat e, Ix i, IArray UArray e) => Flat ( UArray i e) Source #
Instance details Defined in Flat.Instances.Array Methods encode :: UArray i e -> Encoding Source # decode :: Get ( UArray i e) Source # size :: UArray i e -> NumBits -> NumBits Source #
( Flat i, Flat e, Ix i) => Flat ( Array i e) Source #	Array is encoded as (lowBound,highBound,AsArray (elems array)): `>>>` `let arr = A.array ((1::Word,4::Word),(2,5)) [((1,4),11::Word),((1,5),22),((2,4),33),((2,5),44)] in tst (bounds arr,AsArray(elems arr)) == tst arr`True As it's easy to see: `>>>` `tst $ A.array ((1::Word,4::Word),(2,5)) [((1,4),11::Word),((1,5),22),((2,4),33),((2,5),44)]`(True,80,[1,4,2,5,4,11,22,33,44,0]) `>>>` `tst $ A.array ((1,4),(2,5)) [((1,4),"1.4"),((1,5),"1.5"),((2,4),"2.4"),((2,5),"2.5")]`(True,160,[2,8,4,10,4,152,203,166,137,140,186,106,153,75,166,137,148,186,106,0]) Arrays and Unboxed Arrays are encoded in the same way: `>>>` `let bounds = ((1::Word,4::Word),(2,5));elems=[11::Word,22,33,44] in tst (U.listArray bounds elems :: U.UArray (Word,Word) Word) == tst (A.listArray bounds elems)`True
Instance details Defined in Flat.Instances.Array Methods encode :: Array i e -> Encoding Source # decode :: Get ( Array i e) Source # size :: Array i e -> NumBits -> NumBits Source #
Flat ( Fixed a) Source #	`>>>` `test (MkFixed 123 :: Fixed E0)`(True,16,"11110110 00000001") `>>>` `test (MkFixed 123 :: Fixed E0) == test (MkFixed 123 :: Fixed E2)`True
Instance details Defined in Flat.Instances.Base Methods encode :: Fixed a -> Encoding Source # decode :: Get ( Fixed a) Source # size :: Fixed a -> NumBits -> NumBits Source #
( Flat a, Flat b, Ord a) => Flat ( Map a b) Source #	Maps are encoded as lists: `>>>` `tst (Data.Map.empty :: Map () ())`(True,1,[0]) `>>>` `asList Data.Map.fromList [("a","aa"),("b","bb")]`True Key/Values are encoded in order: `>>>` `let l = [("a","aa"),("b","bb")] in tst (Data.Map.fromList l) == tst (Data.Map.fromList $ Prelude.reverse l)`True IntMap and Map are encoded in the same way: `>>>` `let l = [(2::Int,"b"),(1,"a")] in tst (Data.IntMap.fromList l) == tst (Data.Map.fromList l)`True
Instance details Defined in Flat.Instances.Containers Methods encode :: Map a b -> Encoding Source # decode :: Get ( Map a b) Source # size :: Map a b -> NumBits -> NumBits Source #
( Hashable k, Eq k, Flat k, Flat v) => Flat ( HashMap k v) Source #	`>>>` `test (Data.HashMap.Strict.fromList [(1,11),(2,22)])`(True,35,"10000001 00001011 01000001 00001011 000") `>>>` `test (Data.HashMap.Lazy.fromList [(1,11),(2,22)])`(True,35,"10000001 00001011 01000001 00001011 000")
Instance details Defined in Flat.Instances.Unordered Methods encode :: HashMap k v -> Encoding Source # decode :: Get ( HashMap k v) Source # size :: HashMap k v -> NumBits -> NumBits Source #
( Flat a, Flat b, Flat c) => Flat (a, b, c) Source #
Instance details Defined in Flat.Instances.Base Methods encode :: (a, b, c) -> Encoding Source # decode :: Get (a, b, c) Source # size :: (a, b, c) -> NumBits -> NumBits Source #
Flat (f a) => Flat ( Alt f a) Source #	`>>>` `let w = Just (11::Word8); a = Alt w <> Alt (Just 24) in tst a == tst w`True `>>>` `let w = Just (11::Word8); a = Alt Nothing <> Alt w in tst a == tst w`True Since: 0.4.4
Instance details Defined in Flat.Instances.Base Methods encode :: Alt f a -> Encoding Source # decode :: Get ( Alt f a) Source # size :: Alt f a -> NumBits -> NumBits Source #
( Flat a, Flat b, Flat c, Flat d) => Flat (a, b, c, d) Source #
Instance details Defined in Flat.Instances.Base Methods encode :: (a, b, c, d) -> Encoding Source # decode :: Get (a, b, c, d) Source # size :: (a, b, c, d) -> NumBits -> NumBits Source #
( Flat a, Flat b, Flat c, Flat d, Flat e) => Flat (a, b, c, d, e) Source #
Instance details Defined in Flat.Instances.Base Methods encode :: (a, b, c, d, e) -> Encoding Source # decode :: Get (a, b, c, d, e) Source # size :: (a, b, c, d, e) -> NumBits -> NumBits Source #
( Flat a, Flat b, Flat c, Flat d, Flat e, Flat f) => Flat (a, b, c, d, e, f) Source #
Instance details Defined in Flat.Instances.Base Methods encode :: (a, b, c, d, e, f) -> Encoding Source # decode :: Get (a, b, c, d, e, f) Source # size :: (a, b, c, d, e, f) -> NumBits -> NumBits Source #
( Flat a, Flat b, Flat c, Flat d, Flat e, Flat f, Flat g) => Flat (a, b, c, d, e, f, g) Source #
Instance details Defined in Flat.Instances.Base Methods encode :: (a, b, c, d, e, f, g) -> Encoding Source # decode :: Get (a, b, c, d, e, f, g) Source # size :: (a, b, c, d, e, f, g) -> NumBits -> NumBits Source #

getSize :: Flat a => a -> NumBits Source #

Calculate the maximum size in bits of the serialisation of the value

module GHC.Generics

class GFlatEncode f Source #

Generic Encoder

Minimal complete definition

gencode

Instances

Instances details

GFlatEncode ( V1 :: Type -> Type ) Source #
Instance details Defined in Flat.Class Methods gencode :: V1 a -> Encoding
GFlatEncode ( U1 :: Type -> Type ) Source #
Instance details Defined in Flat.Class Methods gencode :: U1 a -> Encoding
Flat a => GFlatEncode ( K1 i a :: Type -> Type ) Source #
Instance details Defined in Flat.Class Methods gencode :: K1 i a a0 -> Encoding
(NumConstructors (a :+: b) <= 512, GFlatEncodeSum (a :+: b)) => GFlatEncode (a :+: b) Source #
Instance details Defined in Flat.Class Methods gencode :: (a :+: b) a0 -> Encoding
( GFlatEncode a, GFlatEncode b) => GFlatEncode (a :*: b) Source #
Instance details Defined in Flat.Class Methods gencode :: (a :*: b) a0 -> Encoding
GFlatEncode a => GFlatEncode ( D1 i ( C1 c a)) Source #
Instance details Defined in Flat.Class Methods gencode :: D1 i ( C1 c a) a0 -> Encoding
GFlatEncode f => GFlatEncode ( M1 i c f) Source #
Instance details Defined in Flat.Class Methods gencode :: M1 i c f a -> Encoding

class GFlatDecode f Source #

Generic Decoding

Minimal complete definition

gget

Instances

Instances details

GFlatDecode ( V1 :: Type -> Type ) Source #	Type without constructors
Instance details Defined in Flat.Class Methods gget :: Get ( V1 t)
GFlatDecode ( U1 :: Type -> Type ) Source #	Constructor without arguments
Instance details Defined in Flat.Class Methods gget :: Get ( U1 t)
Flat a => GFlatDecode ( K1 i a :: Type -> Type ) Source #	Constants, additional parameters, and rank-1 recursion
Instance details Defined in Flat.Class Methods gget :: Get ( K1 i a t)
( GFlatDecode a, GFlatDecode b) => GFlatDecode ( C1 m1 a :+: C1 m2 b) Source #
Instance details Defined in Flat.Class Methods gget :: Get (( C1 m1 a :+: C1 m2 b) t)
(NumConstructors (a :+: b) <= 512, GFlatDecodeSum (a :+: b)) => GFlatDecode (a :+: b) Source #	Data types with up to 512 constructors Uses a custom constructor decoding state instance {-# OVERLAPPABLE #-} (GFlatDecodeSum (a :+: b),GFlatDecode a, GFlatDecode b) => GFlatDecode (a :+: b) where
Instance details Defined in Flat.Class Methods gget :: Get ((a :+: b) t)
( GFlatDecode a, GFlatDecode b) => GFlatDecode (a :*: b) Source #	Product: constructor with parameters
Instance details Defined in Flat.Class Methods gget :: Get ((a :*: b) t)
GFlatDecode a => GFlatDecode ( M1 i c a) Source #	Metadata (constructor name, etc)
Instance details Defined in Flat.Class Methods gget :: Get ( M1 i c a t)

class GFlatSize f Source #

Calculate the number of bits required for the serialisation of a value Implemented as a function that adds the maximum size to a running total

Minimal complete definition

gsize

Instances

Instances details

GFlatSize ( V1 :: Type -> Type ) Source #	Type without constructors
Instance details Defined in Flat.Class Methods gsize :: NumBits -> V1 a -> NumBits
GFlatSize ( U1 :: Type -> Type ) Source #	Constructor without arguments
Instance details Defined in Flat.Class Methods gsize :: NumBits -> U1 a -> NumBits
Flat a => GFlatSize ( K1 i a :: Type -> Type ) Source #	Skip metadata
Instance details Defined in Flat.Class Methods gsize :: NumBits -> K1 i a a0 -> NumBits
GFlatSizeSum (a :+: b) => GFlatSize (a :+: b) Source #
Instance details Defined in Flat.Class Methods gsize :: NumBits -> (a :+: b) a0 -> NumBits
( GFlatSize a, GFlatSize b) => GFlatSize (a :*: b) Source #
Instance details Defined in Flat.Class Methods gsize :: NumBits -> (a :*: b) a0 -> NumBits
GFlatSize f => GFlatSize ( M1 i c f) Source #	Skip metadata
Instance details Defined in Flat.Class Methods gsize :: NumBits -> M1 i c f a -> NumBits