Mavryk_raw_protocol_001_PtAtLas.IndexableIn transaction rollups, some values can be replaced by indexes in the messages sent from the layer-1 to the layer-2.
This module provides various type-safe helpers to manipulate these particular values.
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) tAn 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) tThe type of indexable values identified as not being indexes.
type 'a index = (index_only, 'a) tThe type of indexable values identified as being indexes.
val value : 'a -> 'a valuevalue v wraps v into an indexable value identified as not being an index.
val from_value : 'a -> 'a eitherfrom_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_001_PtAtLas.Error_monad.tzresultindex 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_001_PtAtLas.Error_monad.tzresultfrom_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 indexindex_exn i wraps i into an indexable value identified as being an index.
val from_index_exn : int32 -> 'a eitherfrom_index_exn i wraps i into an indexable value, but forget about the nature of the content of the result.
val compact :
'a Mavryk_protocol_environment_001_PtAtLas.Data_encoding.t ->
(unknown, 'a) t
Mavryk_protocol_environment_001_PtAtLas.Data_encoding.Compact.tcompact 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_001_PtAtLas.Data_encoding.t ->
(unknown, 'a) t Mavryk_protocol_environment_001_PtAtLas.Data_encoding.tval pp :
(Mavryk_protocol_environment_001_PtAtLas.Format.formatter -> 'a -> unit) ->
Mavryk_protocol_environment_001_PtAtLas.Format.formatter ->
('state, 'a) t ->
unitval destruct :
('state, 'a) t ->
('a index, 'a) Mavryk_protocol_environment_001_PtAtLas.Either.tforget x returns an indexable value whose kind of contents has been forgotten.
val to_int32 : 'a index -> int32to_int32 x unwraps and returns the integer behind x.
val to_value : 'a value -> 'ato_value x unwraps and returns the value behind x.
val is_value_e :
error:'trace ->
('state, 'a) t ->
('a, 'trace) Mavryk_protocol_environment_001_PtAtLas.Pervasives.resultis_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.sintin_memory_size a returns the number of bytes allocated in RAM for a.
val size : ('a -> int) -> ('state, 'a) t -> intsize a returns the number of bytes allocated in an inbox to store a.
compare f x y is a total order on indexable values, which proceeds as follows.
x and y are a value, then use f to compare them.x and y are indexes, then uses the Int32.compare function to compare them.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.
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.
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