package tezos-protocol-018-Proxford

  1. Overview
  2. Docs
package tezos-protocol-018-Proxford
Legend:
Library
Module
Module type
Parameter
Class
Class type

In 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 value_only =
  1. | Value_only
type index_only =
  1. | Index_only
type unknown =
  1. | Unknown
type (_, 'a) t = private
  1. | Value : 'a -> (value_only, 'a) t
  2. | Hidden_value : 'a -> (unknown, 'a) t
  3. | Index : int32 -> (index_only, 'a) t
  4. | 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.

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

Returns the error Index_cannot_be_negative iff i <= 0l.

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.

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.

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 destruct : ('state, 'a) t -> ('a index, 'a) Tezos_protocol_environment_018_Proxford.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) Tezos_protocol_environment_018_Proxford.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 Tezos_protocol_environment_018_Proxford.Error_monad.error +=
  1. | Index_cannot_be_negative of int32
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct