Compute encoded size of an integer

A range of values. Should satisfy the invariant forall x. lo x <= hi x.

Fully evaluate a size expression by applying the given function to any suspended computations. szEval g effectively turns each "thunk" of the form TodoF f x into g x, then evaluates the result.

Expressions describing the statically-computed size bounds on a type's possible values.

An individual labeled case.

Discard the label on a case.

A type used to represent the length of a value in Size computations.

Override mechanisms to be used with szWithCtx.

Is this expression a thunk?

Create a case expression from individual cases.

Evaluate the expression lazily, by immediately creating a thunk that will evaluate its contents lazily.

ghci> putStrLn $ pretty $ szLazy (Proxy @TxAux)
(_ :: TxAux)

Evaluate an expression greedily. There may still be thunks in the result, for types that did not provide a custom encodedSizeExpr method in their ToCBOR instance.

ghci> putStrLn $ pretty $ szGreedy (Proxy @TxAux)
(0 + { TxAux=(2 + ((0 + (((1 + (2 + ((_ :: LengthOf [TxIn]) * (2 + { TxInUtxo=(2 + ((1 + 34) + { minBound=1 maxBound=5 })) })))) + (2 + ((_ :: LengthOf [TxOut]) * (0 + { TxOut=(2 + ((0 + ((2 + ((2 + withWordSize((((1 + 30) + (_ :: Attributes AddrAttributes)) + 1))) + (((1 + 30) + (_ :: Attributes AddrAttributes)) + 1))) + { minBound=1 maxBound=5 })) + { minBound=1 maxBound=9 })) })))) + (_ :: Attributes ()))) + (_ :: Vector TxInWitness))) })

Force any thunks in the given Size expression.

ghci> putStrLn $ pretty $ szForce $ szLazy (Proxy @TxAux)
(0 + { TxAux=(2 + ((0 + (_ :: Tx)) + (_ :: Vector TxInWitness))) })

Greedily compute the size bounds for a type, using the given context to override sizes for specific types.

Simplify the given Size, resulting in either the simplified Size or, if it was fully simplified, an explicit upper and lower bound.

Apply a monotonically increasing function to the expression. There are three cases when applying f to a Size expression: * When applied to a value x, compute f x. * When applied to cases, apply to each case individually. * In all other cases, create a deferred application of f.

Serialize a Haskell value with a ToCBOR instance to an external binary representation.

The output is represented as a lazy LByteString and is constructed incrementally.

Serialize a Haskell value to an external binary representation.

The output is represented as a strict ByteString.

Serialize into a Builder. Useful if you want to throw other ByteStrings around it.

Serialize a Haskell value to an external binary representation using the provided CBOR Encoding

The output is represented as an LByteString and is constructed incrementally.

A strict version of serializeEncoding

Encode and serialise the given a and sorround it with the semantic tag 24 In CBOR diagnostic notation: >>> 24(hDEADBEEF)

Like encodeNestedCbor, but assumes nothing about the shape of input object, so that it must be passed as a binary ByteString blob. It's the caller responsibility to ensure the input ByteString correspond indeed to valid, previously-serialised CBOR data.

A wrapper over ByteString for signalling that a bytestring should be processed as a sequence of bytes, not as a separate entity. It's used in crypto and binary code.

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

Decoder for list.

Checks canonicity by comparing the new key being decoded with the previous one, to enfore these are sorted the correct way. See: https://tools.ietf.org/html/rfc7049#section-3.9 "[..]The keys in every map must be sorted lowest value to highest.[...]"

Convert a Buildable error into a cborg decoder error

Convert an Either-encoded failure to a cborg decoder failure

Drop a list of values using the supplied Dropper for each element

Deserialize a Haskell value from the external binary representation (which must have been made using serialize or related function).

Throws: DeserialiseFailure if the given external representation is invalid or does not correspond to a value of the expected type.

Strict variant of deserialize.

Turn an Encoding into a strict ByteString in CBOR binary format.

Since: cborg-0.2.0.0

Deserialize a Haskell value from the external binary representation, failing if there are leftovers. In a nutshell, the full here implies the contract of this function is that what you feed as input needs to be consumed entirely.

Remove the the semantic tag 24 from the enclosed CBOR data item, decoding back the inner ByteString as a proper Haskell type. Consume its input in full.

Like decodeKnownCborDataItem, but assumes nothing about the Haskell type we want to deserialise back, therefore it yields the ByteString Tag 24 surrounded (stripping such tag away).

In CBOR notation, if the data was serialised as:

>>> 24(h'DEADBEEF')

then decodeNestedCborBytes yields the inner DEADBEEF, unchanged.

A pair of offsets delimiting the beginning and end of a substring of a ByteString

A decoder for a value paired with an annotation specifying the start and end of the consumed bytes.

Extract a substring of a given ByteString corresponding to the offsets.

A decoder for a value paired with an annotation specifying the start and end of the consumed bytes.

Decodes a value from a ByteString, requiring that the full ByteString is consumed, and replaces ByteSpan annotations with the corresponding substrings of the input string.

Reconstruct an annotation by re-serialising the payload to a ByteString.

A value of type (Annotator a) is one that needs access to the entire bytestring used during decoding to finish construction of a vaue of type a. A typical use is some type that stores the bytes that were used to deserialize it. For example the type Inner below is constructed using the helper function makeInner which serializes and stores its bytes (using serializeEncoding). Note how we build the Annotator by abstracting over the full bytes, and using those original bytes to fill the bytes field of the constructor Inner. The ToCBOR instance just reuses the stored bytes to produce an encoding (using encodePreEncoded).

data Inner = Inner Int Bool LByteString

makeInner :: Int -> Bool -> Inner
makeInner i b = Inner i b (serializeEncoding (toCBOR i <> toCBOR b))

instance ToCBOR Inner where
  toCBOR (Inner _ _ bytes) = encodePreEncoded bytes

instance FromCBOR (Annotator Inner) where
  fromCBOR = do
     int <- fromCBOR
     trueOrFalse <- fromCBOR
     pure (Annotator ((Full bytes) -> Inner int trueOrFalse bytes))

if an Outer type has a field of type Inner, with a (ToCBOR (Annotator Inner)) instance, the Outer type must also have a (ToCBOR (Annotator Outer)) instance. The key to writing that instance is to use the operation withSlice which returns a pair. The first component is an Annotator that can build Inner, the second is an Annotator that given the full bytes, extracts just the bytes needed to decode Inner.

data Outer = Outer Text Inner

instance ToCBOR Outer where
  toCBOR (Outer t i) = toCBOR t <> toCBOR i

instance FromCBOR (Annotator Outer) where
  fromCBOR = do
    t <- fromCBOR
    (Annotator mkInner, Annotator extractInnerBytes) <- withSlice fromCBOR
    pure (Annotator ( full -> Outer t (mkInner (Full (extractInnerBytes full)))))

The argument is a decoder for a annotator that needs access to the bytes that | were decoded. This function constructs and supplies the relevant piece.

Supplies the bytestring argument to both the decoder and the produced annotator.

Pairs the decoder result with an annotator that can be used to construct the exact bytes used to decode the result.

This marks the entire bytestring used during decoding, rather than the piece we need to finish constructing our value.

Serialize a Haskell value to an external binary representation using the provided CBOR Encoding

The output is represented as an LByteString and is constructed incrementally.

Include pre-encoded valid CBOR data into the Encoding.

The data is included into the output as-is without any additional wrapper.

This should be used with care. The data must be a valid CBOR encoding, but this is not checked.

This is useful when you have CBOR data that you know is already valid, e.g. previously validated and stored on disk, and you wish to include it without having to decode and re-encode it.

Since: cborg-0.2.2.0