Deserialize a Haskell value from a binary CBOR representation, failing if there are leftovers. In other words, the Full here implies the contract on this function that the input must be consumed in its entirety by the decoder specified in DecCBOR.

Same as decodeFull, except accepts a strict ByteString as input instead of the lazy one.

Same as decodeFull, except instead of relying on the DecCBOR instance the Decoder must be suplied manually.

Same as decodeFullDecoder, except works on strict ByteString

Same as decodeFullDecoder, except it provdes the means of passing portion or all of the ByteString input argument to the decoding Annotator.

Same as decodeFullDecoder, decodes a Haskell value from a lazy ByteString, requiring that the full ByteString is consumed, and replaces ByteSpan annotations with the corresponding slice of the input as a strict ByteString.

Convert a versioned DecCBOR instance to a plain Decoder using Byron protocol version and empty ByteString.

This is an abstract interface that does the interning. In other words it does the actual sharing by looking up the supplied value in some existing data structure and uses that value instead. Relying on this interface gives us the benefit of ignoring the type of underlying data structure and allows us to compose many Interns with the monoidal interface provided by Interns wrapper. In order to create an Intern see the internsFromMap or internsFromVMap functions.

Just like decSharePlusCBOR, except allows to transform the shared state with a lens.

Use DecShareCBOR class while ignoring sharing

Using this function it is possible to compose two lenses. One will extract a value and another will used it for placing it into a empty monoid. Here is an example of how a second element of a tuple can be projected on the third element of a 3-tuple.

toMemptyLens _3 _2 == lens (\(_, b) -> (mempty, mempty, b)) (\(a, _) (_, _, b) -> (a, b))

Here is an example where we extract a second element of a tuple and insert it at third position of a three tuple while all other elements are set to mempty:

>>> import Lens.Micro
>>> ("foo","bar") ^. toMemptyLens _3 _2 :: (Maybe String, (), String)
(Nothing,(),"bar")

In the opposite direction of extracting the third element of a 3-tuple and replacing the second element of the tuple the setter is being applied to

>>> ("foo","bar") & toMemptyLens _3 _2 .~ (Just "baz", (), "booyah") :: (String, String)
("foo","booyah")

Share every item in a functor, have deserializing it

A 0-based offset within the overall byte sequence that makes up the input to the Decoder.

This is an Int64 since Decoder is incremental and can decode more data than fits in memory at once. This is also compatible with the result type of length.

The type of a token, which a decoder can ask for at an arbitrary time.

Since: cborg-0.2.0.0

An action, representing a step for a decoder to taken and a continuation to invoke with the expected value.

Since: cborg-0.2.0.0

Convert a Buildable error message into a MonadFail failure.

Convert an Either-encoded failure to a MonadFail failure using the Buildable insatance

Report an error when a numeric key of the type constructor doesn't match.

Promote a regular Decoder to a versioned one. Which means it will work for all versions.

Extract the underlying Decoder by optionally supplying the original bytes and specifying the concrete version to be used.

Use the supplied decoder as a plain decoder with current version.

Ignore the current version of the decoder and enforce the supplied one instead.

Extract current version of the decoder

>>> import Cardano.Ledger.Decoding
>>> decodeFullDecoder 3 "Version" getDecoderVersion ""
Right 3

Conditionally choose the newer or older decoder, depending on the current version. Version in the context of encoders/decoders is the major protocol version. Supplied version acts as a pivot.

Example

>>> newtype Foo = Foo Word32
>>> decFoo = Foo <$> ifDecoderVersionAtLeast 2 decodeWord32 (fromIntegral <$> decodeWord16)

Optionally run a decoder depending on the current version and the supplied one.

Optionally run a decoder depending on the current version and the supplied one.

Decoder for Rational. Versions variance:

• [>= 9] - Allows variable as well as exact list length encoding. Consumes tag 30 if one is present, but does not enforce it.
• [>= 2] - Allows variable as well as exact list length encoding.
• [== 1] - Expects exact list length encoding.

Enforces tag 30 to indicate a rational number, as per tag assignment: https://www.iana.org/assignments/cbor-tags/cbor-tags.xhtml

https://peteroupc.github.io/CBOR/rational.html

Decoder for list.

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

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.

Unlike decodeMaybe this allows variable as well as exact list length encoding for all versions, because Byron never used StrictMaybe type.

Alternative way to decode a StrictMaybe type.

Note - this is not the default method for decoding StrictMaybe, use decodeStrictMaybe instead.

Use this decoder for any list like structure that accepts fixed or variable list length encoding.

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")])

Just like decodeMap, but also gives access to the key for the value decoder.

Similar to decodeMapByKey, except it gives access to the key value decoder as a pair and allows for different type of length encoding

Decode VMap. Unlike decodeMap it does not behavee differently for version prior to 2.

We stitch a `258` in from of a (Hash)Set, so that tools which programmatically check for canonicity can recognise it from a normal array. Why 258? This will be formalised pretty soon, but IANA allocated 256...18446744073709551615 to "First come, first served": https://www.iana.org/assignments/cbor-tags/cbor-tags.xhtml Currently `258` is the first unassigned tag and as it requires 2 bytes to be encoded, it sounds like the best fit.

https://github.com/input-output-hk/cbor-sets-spec/blob/master/CBOR_SETS.md

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

Decode a collection of values with ability to supply length decoder. Number of decoded elements will be returned together with the data structure

Decode a collection of values with ability to supply length decoder. Duplicates are not allowed.

Decode a Set as a either a definite or indefinite list. Duplicates are not allowed. Set tag 258 is permitted, but not enforced.

Generic decoder for vectors. Its intended use is to allow easy definition of Serialise instances for custom vector

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 UTCTime. Versions variance:

• [>= 2] - Allows variable list length encoding, but still expects number of elements to be 3.
• [< 2] - Expects exact list length encoding to be 3

Convert a Get monad from binary package into a Decoder

Enforces that the input size is the same as the decoded one, failing in case it's not

Compare two sizes, failing if they are not equal