Module Make.Data_encoding

In memory JSON data

Defines a JSON schema for positive 32-bit integers (ranging from 0 to Int32.max_int inclusive), primarily for encoding purposes in raw_level_repr.ml.

To keep the protocol concise and manageable, we choose to use ad-hoc schemas rather than exporting the entire data-encoding library's schema types and constructors. This approach enables us to address specific cases effectively without burdening the codebase with a complex and unnecessary schema definition.

In most situations, the default schemas should suffice. However, when dealing with exceptional cases, targeted fixes can be implemented. One potential trade-off is that changes to the environment may be necessary when such cases arise.

The type descriptors for values of type 'a.

Special value null in JSON, nothing in binary.

Empty object (not included in binary, encoded as empty object in JSON).

Unit value, omitted in binary. Serialized as an empty object in JSON, accepts any object when deserializing.

Constant string (data is not included in the binary data).

Signed 8 bit integer (data is encoded as a byte in binary and an integer in JSON).

Unsigned 8 bit integer (data is encoded as a byte in binary and an integer in JSON).

Signed 16 bit integer (data is encoded as a short in binary and an integer in JSON).

Unsigned 16 bit integer (data is encoded as a short in binary and an integer in JSON).

Signed 31 bit integer, which corresponds to type int on 32-bit OCaml systems (data is encoded as a 32 bit int in binary and an integer in JSON).

Signed 32 bit integer (data is encoded as a 32-bit int in binary and an integer in JSON).

Signed 64 bit integer (data is encoded as a 64-bit int in binary and a decimal string in JSON).

Integer with bounds in a given range. Both bounds are inclusive.

• raises Invalid_argument

  if the bounds are beyond the interval -2^30; 2^30-1. These bounds are chosen to be compatible with all versions of OCaml.

Big number In JSON, data is encoded as a decimal string. In binary, data is encoded as a variable length sequence of bytes, with a running unary size bit: the most significant bit of each byte tells is this is the last byte in the sequence (0) or if there is more to read (1). The second most significant bit of the first byte is reserved for the sign (positive if zero). Binary_size and sign bits ignored, data is then the binary representation of the absolute value of the number in little-endian order.

Positive big number, see z.

uint_like_n () is an encoding for int which uses the same representation as n.

For compatibility with 32-bit machines, this encoding supports the same range of encodings as int31, but only the positive ones. I.e., it supports the inclusive range 0 to (1 lsl 30) - 1.

The optional parameter ?max_value can be used to further restrict the range of values. If max_value is set and is greater than (1 lsl 30) - 1 then the function raises Invalid_argument.

The encoding is partial: attempting to de/serialise values which are outside of the supported range will fail. In addition, in binary, a maximum size for the serialised representation is computed based on the maximum value in the range, and the de/serialisation process fails before attempting any conversion if the size is exceeded.

• raises Invalid_argument

  if max_value < 0 or max_value > (1 lsl 30) - 1

int_like_z () is an encoding for int which uses the same representation as z.

For compatibility with 32-bit machines, this encoding supports the same range of encodings as int31. I.e., it supports the inclusive range -(1 lsl 30) to (1 lsl 30) - 1.

The optional parameters ?min_value and ?max_value can be used to further restrict the range of values. If min_value is set and less than -(1 lsl 30) or if max_value is set and is greater than (1 lsl 30) - 1 then the function raises Invalid_argument.

The encoding is partial: attempting to de/serialise values which are outside of the supported range will fail. In addition, in binary, a maximum size for the serialised representation is computed based on the encoding's range, and the de/serialisation process fails before attempting any conversion if the size is exceeded.

• raises Invalid_argument

  if max_value < min_value

• raises Invalid_argument

  if max_value > (1 lsl 30) - 1

• raises Invalid_argument

  if min_value < -(1 lsl 30)

Other ground type encodings

Encoding of a boolean (data is encoded as a byte in binary and a boolean in JSON).

Encoding of a string

• In binary, encoded as a byte sequence prefixed by the length of the string. The length is represented as specified by the length_kind parameter (default `Uint30).
• in JSON when string_json_repr = Plain, encoded as a string
• in JSON when string_json_repr = Hex, encoded via hex.

Encoding of arbitrary bytes. See string

Combinator to make an optional value (represented as a 1-byte tag followed by the data (or nothing) in binary and either the raw value or a null in JSON).

Note that the JSON representation is only weakly discriminating. Specifically, the value Some None is represented as the raw value None and so the two are indistinguishable. For this reason, this combinator does not support nesting, nor does it support use within a recursive (mu) encoding.

• raises Invalid_argument

  if called on an encoding which may be represented as null in JSON. This includes an encoding of the form option _, conv _ _ (option _), dynamic_size (option _), etc.

• raises Invalid_argument

  if called within the body of a mu.

Combinator to make a result value (represented as a 1-byte tag followed by the data of either type in binary, and either unwrapped value in JSON (the caller must ensure that both encodings do not collide)).

List combinator.

• encoded as an array in JSON
• encoded as the concatenation of all the element in binary prefixed its size in bytes

• parameter [max_length]

  If max_length is passed and the encoding of elements has fixed size, a check_size is automatically added for earlier rejection.

• raises Invalid_argument

  if the inner encoding is variable.

List combinator.

• encoded as an array in JSON
• encoded as the concatenation of its length (number of elements) and all the element in binary

• parameter kind

  ([`N | `Uint8 | `Uint16 | `Uint30]) controls the representation of the length: uint_like_n, uint8, uint16, or int31 (but only positive values).

• parameter [max_length]

  If max_length is passed and the encoding of elements has fixed size, a check_size is automatically added for earlier rejection.

• raises Invalid_argument

  if the inner encoding is variable.

Provide a transformer from one encoding to a different one.

Used to simplify nested encodings or to change the generic tuples built by obj1, tup1 and the like into proper records.

A schema may optionally be provided as documentation of the new encoding.

conv_with_guard is similar to conv but the function that takes in the value from the outside (untrusted) world has a chance to fail.

Specifically, if the function returns Error msg then the decoding is interrupted with an error carrying the message msg. If the function returns Ok _ then the decoding proceeds normally.

with_decoding_guard g e is similar to e but decoding fails if g returns Error _ on the decoded value.

Association list. An object in JSON, a list of pairs in binary.

An enriched encoding to represent a component in a structured type, augmenting the encoding with a name and whether it is a required or optional. Fields are used to encode OCaml tuples as objects in JSON, and as sequences in binary, using combinator obj1 and the like.

Required field.

Optional field. Omitted entirely in JSON encoding if None. Omitted in binary if the only optional field in a `Variable encoding, otherwise a 1-byte prefix (`0` or `255`) tells if the field is present or not.

Optional field of variable length. Only one can be present in a given object.

Required field with a default value. If the default value is passed, the field is omitted in JSON. The value is always serialized in binary.

Create a larger object from the encodings of two smaller ones.

• raises Invalid_argument

  if both arguments are not objects or if both tuples contains a variable field..

With_field_name_duplicate_checks is a subset of Encoding where all the constructed objects are checked for duplicates.

Create a large tuple encoding from two smaller ones.

• raises Invalid_argument

  if both values are not tuples or if both tuples contains a variable field.

A partial encoding to represent a case in a variant type. Hides the (existentially bound) type of the parameter to the specific case, providing its encoder, and converter functions to and from the union type.

A sum descriptor can be optimized by providing a specific matching_function which efficiently determines in which case some value of type 'a falls.

Note that in general you should use a total function (i.e., one defined over the whole of the 'a type) for the matching_function. However, in the case where you have a good reason to use a partial function, you should raise No_case_matched in the dead branches. Reasons why you may want to do so include:

• 'a is an open variant and you will complete the matching function later, and
• there is a code invariant that guarantees that 'a is not fully inhabited.

matched t e u represents the fact that a value is tagged with t and carries the payload u which can be encoded with e.

The optional argument tag_size must match the one passed to the matching function matched is called inside of.

An example is given in the documentation of matching.

• raises [Invalid_argument]

  if t < 0

• raises [Invalid_argument]

  if t does not fit in tag_size

Encodes a variant constructor. Takes the encoding for the specific parameters, a recognizer function that will extract the parameters in case the expected case of the variant is being serialized, and a constructor function for deserialization.

The tag must be less than the tag size of the union in which you use the case. An optional tag gives a name to a case and should be used to maintain compatibility.

An optional name for the case can be provided, which is used in the binary documentation.

• raises [Invalid_argument]

  if case_tag is Tag t with t < 0

Create a single encoding from a series of cases.

In JSON, all cases are tried one after the other using the case list. The caller is responsible for avoiding collisions. If there are collisions (i.e., if multiple cases produce the same JSON output) then the encoding and decoding processes might not be inverse of each other. In other words, destruct e (construct e v) may not be equal to v.

In binary, a prefix tag is added to discriminate quickly between cases. The default is `Uint8 and you must use a `Uint16 if you are going to have more than 256 cases.

The matching function is used during binary encoding of a value v to efficiently determine which of the cases corresponds to v. The case list is used during decoding to reconstruct a value based on the encoded tag. (Decoding is optimised internally: tag look-up has a constant cost.)

The caller is responsible for ensuring that the matching_function and the case list describe the same encoding. If they describe different encodings, then the decoding and encoding processes will not be inverses of each others. In other words, of_bytes e (to_bytes e v) will not be equal to v.

If you do not wish to be responsible for this, you can use the unoptimised union that uses a case list only (see below). Beware that in union the complexity of the encoding is linear in the number of cases.

Following: a basic example use. Note that the matching_function uses the same tags, payload conversions, and payload encoding as the case list.

type t = A of string | B of int * int | C
let encoding_t =
  (* Tags and payload encodings for each constructors *)
  let a_tag = 0 and a_encoding = string in
  let b_tag = 1 and b_encoding = obj2 (req "x" int) (req "y" int) in
  let c_tag = 2 and c_encoding = unit in
  matching
    (* optimised encoding function *)
    (function
       | A s -> matched a_tag a_encoding s
       | B (x, y) -> matched b_tag b_encoding (x, y)
       | C -> matched c_tag c_encoding ())
    (* decoding case list *)
    [
       case ~title:"A"
         (Tag a_tag)
         a_encoding
         (function A s -> Some s | _ -> None) (fun s -> A s);
       case ~title:"B"
         (Tag b_tag)
         b_encoding
         (function B (x, y) -> Some (x, y) | _ -> None) (fun (x, y) -> B (x, y));
       case ~title:"C"
         (Tag c_tag)
         c_encoding
         (function C -> Some () | _ -> None) (fun () -> C);
    ]

• raises [Invalid_argument]

  if it is given an empty case list

• raises [Invalid_argument]

  if there are more than one case with the same tag in the case list

• raises [Invalid_argument]

  if there are more cases in the case list than can fit in the tag_size

Same as matching except that the matching function is a linear traversal of the cases.

• raises [Invalid_argument]

  if it is given an empty case list

• raises [Invalid_argument]

  if there are more than one case with the same tag in the case list

• raises [Invalid_argument]

  if there are more cases in the case list than can fit in the tag_size

With_JSON_discriminant is a subset of Encoding where the union/matching combinators (and associated functions) add discriminant for the JSON backend.

Encode enumeration via association list

• represented as a string in JSON and
• represented as an integer representing the element's position in the list in binary. The integer size depends on the list size.

Create encodings that produce data of a fixed length when binary encoded. See the preamble for an explanation.

Create encodings that produce data of a variable length when binary encoded. See the preamble for an explanation.

Mark an encoding as being of dynamic size. Forces the size to be stored alongside content when needed. Typically used to combine two variable encodings in a same objects or tuple, or to use a variable encoding in an array or a list.

check_size size encoding ensures that the binary encoding of a value will not be allowed to exceed size bytes. The reader and the writer fails otherwise. This function do not modify the JSON encoding.

• raises Invalid_argument

  if size < 0

Define different encodings for JSON and binary serialization.

Combinator for recursive encodings.

Notice that the function passed to mu must be pure. Otherwise, the behavior is unspecified.

A stateful recursive encoding can still be put under a delayed combinator to make sure that a new encoding is generated each time it is used. Caching the encoding generation when the state has not changed is then the responsibility of the client.

Give a name to an encoding and optionally add documentation to an encoding.

See lazy_encoding below.

Combinator to have a part of the binary encoding lazily deserialized. This is transparent on the JSON side.

Force the decoding (memoized for later calls), and return the value if successful.

Obtain the bytes without actually deserializing. Will serialize and memoize the result if the value is not the result of a lazy deserialization.

Make a lazy value from an immediate one.

Apply on structure of lazy value, and combine results

This module provides specialized encoding combinators that are implemented to reduce the size of the serialization result.