Indexable (mavryk-protocol-alpha.Mavryk_raw_protocol

type value_only =

| Value_only

type index_only =

| Index_only

type unknown =

| Unknown

type (_, 'a) t = private

| Value : 'a -> (value_only, 'a) t
| Hidden_value : 'a -> (unknown, 'a) t
| Index : int32 -> (index_only, 'a) t
| Hidden_index : int32 -> (unknown, 'a) t

An indexable value is a value which can be replaced by an integer. The first type parameter determines whether or not this replacement has happened already.

type 'a value = (value_only, 'a) t

The type of indexable values identified as not being indexes.

type 'a index = (index_only, 'a) t

The type of indexable values identified as being indexes.

type 'a either = (unknown, 'a) t

The type of indexable values whose content is still unknown.

val value : 'a -> 'a value

value v wraps v into an indexable value identified as not being an index.

val from_value : 'a -> 'a either

from_value v wraps v into an indexable value, but forget about the nature of the content of the result.

val index : 
  int32 ->
  'a index Mavryk_protocol_environment_alpha.Error_monad.tzresult

index i wraps i into an indexable value identified as being an index.

Returns the error Index_cannot_be_negative iff i <= 0l.

val from_index : 
  int32 ->
  'a either Mavryk_protocol_environment_alpha.Error_monad.tzresult

from_index i wraps i into an indexable value, but forget about the nature of the content of the result.

Returns the error Index_cannot_be_negative iff i <= 0l.

val index_exn : int32 -> 'a index

index_exn i wraps i into an indexable value identified as being an index.

raises Invalid_argument
iff i <= 0l.

val from_index_exn : int32 -> 'a either

from_index_exn i wraps i into an indexable value, but forget about the nature of the content of the result.

raises Invalid_argument
iff i <= 0l.

val compact : 
  'a Mavryk_protocol_environment_alpha.Data_encoding.t ->
  (unknown, 'a) t Mavryk_protocol_environment_alpha.Data_encoding.Compact.t

compact val_encoding is a combinator to derive a compact encoding for an indexable value of type 'a from an encoding for 'a. It uses two bits in the shared tag. 00 is used for indexes fitting in one byte, 01 for indexes fitting in two bytes, 10 for indexes fitting in four bytes, and 11 for the values of type 'a.

val encoding : 
  'a Mavryk_protocol_environment_alpha.Data_encoding.t ->
  (unknown, 'a) t Mavryk_protocol_environment_alpha.Data_encoding.t

val pp : 
  (Mavryk_protocol_environment_alpha.Format.formatter -> 'a -> unit) ->
  Mavryk_protocol_environment_alpha.Format.formatter ->
  ('state, 'a) t ->
  unit

val destruct : 
  ('state, 'a) t ->
  ('a index, 'a) Mavryk_protocol_environment_alpha.Either.t

destruct x returns either the index or the (unwrapped) value contained in x.

Note: If you want to manipulate a value of type value, you can use value.

val forget : ('state, 'a) t -> (unknown, 'a) t

forget x returns an indexable value whose kind of contents has been forgotten.

val to_int32 : 'a index -> int32

to_int32 x unwraps and returns the integer behind x.

val to_value : 'a value -> 'a

to_value x unwraps and returns the value behind x.

val is_value_e : 
  error:'trace ->
  ('state, 'a) t ->
  ('a, 'trace) Mavryk_protocol_environment_alpha.Pervasives.result

is_value_e err x unwraps and returns the value behind x, and throws an err if x is an index.

val in_memory_size : 
  ('a -> Cache_memory_helpers.sint) ->
  ('state, 'a) t ->
  Cache_memory_helpers.sint

in_memory_size a returns the number of bytes allocated in RAM for a.

val size : ('a -> int) -> ('state, 'a) t -> int

size a returns the number of bytes allocated in an inbox to store a.

val compare : ('a -> 'a -> int) -> ('state, 'a) t -> ('state', 'a) t -> int

compare f x y is a total order on indexable values, which proceeds as follows.

If both x and y are a value, then use f to compare them.
If both x and y are indexes, then uses the Int32.compare function to compare them.
Finally, if x and y have not the same kind, the logic is that indexes are smaller than values.

Note: This can be dangerous, as you may end up comparing two things that are equivalent (a value and its index) but declare they are not equal.

val compare_values : ('a -> 'a -> int) -> 'a value -> 'a value -> int

compare_values f x y compares the value x and y using f, and relies on the type system of OCaml to ensure that x and y are indeed both values.

val compare_indexes : 'a index -> 'a index -> int

compare_indexes x y compares the indexes x and y, and relies on the type system of OCaml to ensure that x and y are indeed both indexes.

module type VALUE = sig ... end

module Make (V : VALUE) : sig ... end

type Mavryk_protocol_environment_alpha.Error_monad.error +=

| Index_cannot_be_negative of int32