Flat.Instances.Mono

Documentation

sizeSequence :: (IsSequence mono, Flat (Element mono)) => mono -> NumBits -> NumBits

Calculate size of an instance of IsSequence as the sum:

• of the size of all the elements
• plus the size of the array constructors (1 byte every 255 elements plus one final byte)

encodeSequence :: (Flat (Element mono), MonoFoldable mono) => mono -> Encoding

Encode an instance of IsSequence, as an array

decodeSequence :: (Flat (Element b), IsSequence b) => Get b

Decode an instance of IsSequence, as an array

sizeList :: (MonoFoldable mono, Flat (Element mono)) => mono -> NumBits -> NumBits

encodeList :: (Flat (Element mono), MonoFoldable mono) => mono -> Encoding

decodeList :: (IsSequence b, Flat (Element b)) => Get b

sizeSet :: (IsSet set, Flat (Element set)) => Size set

encodeSet :: (IsSet set, Flat (Element set)) => set -> Encoding

decodeSet :: (IsSet set, Flat (Element set)) => Get set

sizeMap :: (Flat (ContainerKey r), Flat (MapValue r), IsMap r) => Size r

encodeMap :: (Flat (ContainerKey map), Flat (MapValue map), IsMap map) => map -> Encoding

Encode an instance of IsMap, as a list of (Key,Value) tuples

decodeMap :: (Flat (ContainerKey map), Flat (MapValue map), IsMap map) => Get map

Decode an instance of IsMap, as a list of (Key,Value) tuples

newtype AsArray a

Sequences are defined as Arrays:

Array v = A0 | A1 v (Array v) | A2 v v (Array v) ... | A255 ... (Array v)

In practice, this means that the sequence is encoded as a 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.

Lists are defined as:

List a ≡ Nil | Cons a (List a)

In practice, this means that the list elements will be prefixed with a 1 bit and followed by a final 0 bit.

The AsList/AsArray wrappers can be used to serialise sequences as Lists or Arrays.

Let's see some examples.

>>> flatBits $ AsList [True,True,True]
"1111110"

So we have Cons True (11) repeated three times, followed by a final Nil (0).

The list encoding is the default one for lists so AsList is in this case unnecessary:

>>> flatBits $ [True,True,True]
"1111110"

We can force a list to be encoded as an Array with AsArray:

>>> flatBits $ AsArray [True,True,True]
"00000011 11100000 000"

We have the initial block with a count of 3 (3 == 00000011) followed by the elements True True True (111) and then the final block of 0 elements ("00000 000").

>>> flatBits $ [AsArray [True,True,True]]
"10000001 11110000 00000"

>>> flatBits $ (True,True,True,AsArray $ replicate 7 True)
"11100000 11111111 11000000 00"

>>> flatBits $ AsArray ([]::[()])
"00000000"

>>> flatBits $ AsList ([]::[()])
"0"

>>> tst (AsList [11::Word8,22,33])
(True,28,[133,197,164,32])

>>> tst (AsSet (Data.Set.fromList [11::Word8,22,33]))
(True,28,[133,197,164,32])

>>> tst [AsArray [1..3], AsArray [4..8]]
(True,99,[129,129,2,3,0,65,66,2,131,3,132,0,0])

>>> tst $ [AsArray [(1::Word8)..3], AsArray [4..8]]
(True,99,[129,128,129,1,128,65,65,1,65,129,194,0,0])

>>> tst $ [AsArray [(1::Int)..3]]
(True,42,[129,129,2,3,0,0])

Constructors

AsArray

Fields

• unArray :: a

Instances

Show a => Show (AsArray a)

Defined in Flat.Instances.Mono

Methods

showsPrec :: Int -> AsArray a -> ShowS

show :: AsArray a -> String

showList :: [AsArray a] -> ShowS

(IsSequence r, Flat (Element r)) => Flat (AsArray r)

Defined in Flat.Instances.Mono

Methods

encode :: AsArray r -> Encoding

decode :: Get (AsArray r)

size :: AsArray r -> NumBits -> NumBits

Eq a => Eq (AsArray a)

Defined in Flat.Instances.Mono

Methods

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

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

Ord a => Ord (AsArray a)

Defined in Flat.Instances.Mono

Methods

compare :: AsArray a -> AsArray a -> Ordering

(<) :: AsArray a -> AsArray a -> Bool

(<=) :: AsArray a -> AsArray a -> Bool

(>) :: AsArray a -> AsArray a -> Bool

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

max :: AsArray a -> AsArray a -> AsArray a

min :: AsArray a -> AsArray a -> AsArray a

newtype AsList a

Constructors

AsList

Fields

• unList :: a

Instances

Show a => Show (AsList a)

Defined in Flat.Instances.Mono

Methods

showsPrec :: Int -> AsList a -> ShowS

show :: AsList a -> String

showList :: [AsList a] -> ShowS

(IsSequence l, Flat (Element l)) => Flat (AsList l)

Defined in Flat.Instances.Mono

Methods

encode :: AsList l -> Encoding

decode :: Get (AsList l)

size :: AsList l -> NumBits -> NumBits

Eq a => Eq (AsList a)

Defined in Flat.Instances.Mono

Methods

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

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

Ord a => Ord (AsList a)

Defined in Flat.Instances.Mono

Methods

compare :: AsList a -> AsList a -> Ordering

(<) :: AsList a -> AsList a -> Bool

(<=) :: AsList a -> AsList a -> Bool

(>) :: AsList a -> AsList a -> Bool

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

max :: AsList a -> AsList a -> AsList a

min :: AsList a -> AsList a -> AsList a

newtype AsSet a

Sets are saved as lists of values.

>>> tstBits $ AsSet (Data.Set.fromList ([False,True,False]::[Bool]))
(True,5,"10110")

Constructors

AsSet

Fields

• unSet :: a

Instances

Show a => Show (AsSet a)

Defined in Flat.Instances.Mono

Methods

showsPrec :: Int -> AsSet a -> ShowS

show :: AsSet a -> String

showList :: [AsSet a] -> ShowS

(IsSet set, Flat (Element set)) => Flat (AsSet set)

Defined in Flat.Instances.Mono

Methods

encode :: AsSet set -> Encoding

decode :: Get (AsSet set)

size :: AsSet set -> NumBits -> NumBits

Eq a => Eq (AsSet a)

Defined in Flat.Instances.Mono

Methods

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

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

Ord a => Ord (AsSet a)

Defined in Flat.Instances.Mono

Methods

compare :: AsSet a -> AsSet a -> Ordering

(<) :: AsSet a -> AsSet a -> Bool

(<=) :: AsSet a -> AsSet a -> Bool

(>) :: AsSet a -> AsSet a -> Bool

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

max :: AsSet a -> AsSet a -> AsSet a

min :: AsSet a -> AsSet a -> AsSet a

newtype AsMap a

Maps are saved as lists of (key,value) tuples.

>>> tst (AsMap (Data.Map.fromList ([]::[(Word8,())])))
(True,1,[0])

>>> tst (AsMap (Data.Map.fromList [(3::Word,9::Word)]))
(True,18,[129,132,128])

Constructors

AsMap

Fields

• unMap :: a

Instances

Show a => Show (AsMap a)

Defined in Flat.Instances.Mono

Methods

showsPrec :: Int -> AsMap a -> ShowS

show :: AsMap a -> String

showList :: [AsMap a] -> ShowS

(IsMap map, Flat (ContainerKey map), Flat (MapValue map)) => Flat (AsMap map)

Defined in Flat.Instances.Mono

Methods

encode :: AsMap map -> Encoding

decode :: Get (AsMap map)

size :: AsMap map -> NumBits -> NumBits

Eq a => Eq (AsMap a)

Defined in Flat.Instances.Mono

Methods

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

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

Ord a => Ord (AsMap a)

Defined in Flat.Instances.Mono

Methods

compare :: AsMap a -> AsMap a -> Ordering

(<) :: AsMap a -> AsMap a -> Bool

(<=) :: AsMap a -> AsMap a -> Bool

(>) :: AsMap a -> AsMap a -> Bool

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

max :: AsMap a -> AsMap a -> AsMap a

min :: AsMap a -> AsMap a -> AsMap a