Documentation

Decoder for list.

• [>= 2] - Allows variable as well as exact list length encoding.
• [< 2] - Expects variable list length encoding

Decoder for Seq. Same behavior for all versions, allows variable as well as exact list length encoding

Decoder for StrictSeq. Same behavior for all versions, allows variable as well as exact list length encoding.

Decoder for Set. Versions variance:

• [>= 9] - Allows variable as well as exact list length encoding. Duplicates are not allowed. Set tag 258 is permitted, but not enforced.
• [>= 2, < 9] - Allows variable as well as exact list length encoding. Duplicates are silently ignored, set tag 258 is not permitted.
• [< 2] - Expects exact list length encoding and enforces strict order without any duplicates. Also enforces special set tag 258, which was abandoned starting with version 2

Decoder for Map. Versions variance:

• [>= 9] - Allows variable as well as exact list length encoding. Duplicate keys will result in a deserialization failure
• [>= 2] - Allows variable as well as exact list length encoding. Duplicate keys are silently ignored
• [< 2] - Expects exact list length encoding and enforces strict order without any duplicates.

An example of how to use versioning

>>> :set -XOverloadedStrings
>>> import Codec.CBOR.FlatTerm
>>> fromFlatTerm (toPlainDecoder 1 (decodeMap decodeInt decodeBytes)) [TkMapLen 2,TkInt 1,TkBytes "Foo",TkInt 2,TkBytes "Bar"]
Right (fromList [(1,"Foo"),(2,"Bar")])
>>> fromFlatTerm (toPlainDecoder 1 (decodeMap decodeInt decodeBytes)) [TkMapBegin,TkInt 1,TkBytes "Foo",TkInt 2,TkBytes "Bar"]
Left "decodeMapLen: unexpected token TkMapBegin"
>>> fromFlatTerm (toPlainDecoder 2 (decodeMap decodeInt decodeBytes)) [TkMapBegin,TkInt 1,TkBytes "Foo",TkInt 2,TkBytes "Bar",TkBreak]
Right (fromList [(1,"Foo"),(2,"Bar")])

Decoder for Maybe. Versions variance:

• [>= 2] - Allows variable as well as exact list length encoding.
• [< 2] - Expects exact list length encoding

Alternative way to decode a Maybe type.

Note - this is not the default method for decoding Maybe, use decodeMaybe instead.

Encode any Foldable with the variable list length encoding, which will use indefinite encoding over 23 elements and definite otherwise.

Encode a data structure as a Map with the 0-based index for a Key to a value. Uses variable map length encoding, which means an indefinite encoding for maps with over 23 elements and definite otherwise.

Alternative way to encode a Maybe type.

Note - this is not the default method for encoding Maybe, use encodeMaybe instead

Encode a Map. Versions variance:

• [>= 2] - Variable length encoding for Maps larger than 23 key value pairs, otherwise exact length encoding
• [< 2] - Variable length encoding.

Translation function between values through a related binary representation. This function allows you to translate one type into another (or the same one) through their common binary format. It is possible for the source type to be encoded with a different version than the version that will be used for decoding. This is useful for types that build upon one another and are "upgradeable" through their binary representation. It is important to note that the deserialization will happen with Annotator, since that is usually the way we deserialize upgradeable types that live on chain. Moreover, encoding does not require a version, because memoized types that were decoded with annotation will have the bytes retained and thus will have the ToCBOR instance.

Run a ByteString Builder using a strategy aimed at making smaller things efficiently.

It takes a size hint and produces a strict ByteString. This will be fast when the size hint is the same or slightly bigger than the true size.

A CBOR deserialized value together with its size. When deserializing use either decodeSized or its DecCBOR instance.

Use mkSized to construct such value.

Construct a Sized value by serializing it first and recording the amount of bytes it requires. Note, however, CBOR serialization is not canonical, therefore it is *NOT* a requirement that this property holds:

sizedSize (mkSized a) === sizedSize (unsafeDeserialize (serialize a) :: a)

Take a lens that operates on a particular type and convert it into a lens that operates on the Sized version of the type.