Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
PlutusCore.Flat.Instances.Mono
Synopsis
- sizeSequence ∷ (IsSequence mono, Flat (Element mono)) ⇒ mono → NumBits → NumBits
- encodeSequence ∷ (Flat (Element mono), MonoFoldable mono) ⇒ mono → Encoding
- decodeSequence ∷ (Flat (Element b), IsSequence b) ⇒ Get b
- 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
- decodeMap ∷ (Flat (ContainerKey map), Flat (MapValue map), IsMap map) ⇒ Get map
- newtype AsArray a = AsArray {
- unArray ∷ a
- newtype AsList a = AsList {
- unList ∷ a
- newtype AsSet a = AsSet {
- unSet ∷ a
- newtype AsMap a = AsMap {
- unMap ∷ a
Documentation
sizeSequence ∷ (IsSequence mono, Flat (Element mono)) ⇒ mono → NumBits → NumBits Source #
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 Source #
Encode an instance of IsSequence, as an array
decodeSequence ∷ (Flat (Element b), IsSequence b) ⇒ Get b Source #
Decode an instance of IsSequence, as an array
encodeList ∷ (Flat (Element mono), MonoFoldable mono) ⇒ mono → Encoding Source #
decodeList ∷ (IsSequence b, Flat (Element b)) ⇒ Get b Source #
encodeMap ∷ (Flat (ContainerKey map), Flat (MapValue map), IsMap map) ⇒ map → Encoding Source #
Encode an instance of IsMap, as a list of (Key,Value) tuples
decodeMap ∷ (Flat (ContainerKey map), Flat (MapValue map), IsMap map) ⇒ Get map Source #
Decode an instance of IsMap, as a list of (Key,Value) tuples
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])
Instances
Show a ⇒ Show (AsArray a) Source # | |
Eq a ⇒ Eq (AsArray a) Source # | |
Ord a ⇒ Ord (AsArray a) Source # | |
Defined in PlutusCore.Flat.Instances.Mono | |
(IsSequence r, Flat (Element r)) ⇒ Flat (AsArray r) Source # | |
Instances
Show a ⇒ Show (AsList a) Source # | |
Eq a ⇒ Eq (AsList a) Source # | |
Ord a ⇒ Ord (AsList a) Source # | |
Defined in PlutusCore.Flat.Instances.Mono | |
(IsSequence l, Flat (Element l)) ⇒ Flat (AsList l) Source # | |
Sets are saved as lists of values.
>>>
tstBits $ AsSet (Data.Set.fromList ([False,True,False]::[Bool]))
(True,5,"10110")
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])