# package octez-libs

```
include TREE
with type t := t
and type key := key
and type value := value
and type tree := tree
```

```
include VIEW
with type t := tree
and type tree := tree
with type key := key
with type value := value
```

### Getters

`mem t k`

is an Lwt promise that resolves to `true`

iff `k`

is bound to a value in `t`

.

`find t k`

is an Lwt promise that resolves to `Some v`

if `k`

is bound to the value `v`

in `t`

and `None`

otherwise.

`list t key`

is the list of files and sub-nodes stored under `k`

in `t`

. The result order is not specified but is stable.

`offset`

and `length`

are used for pagination.

`length t key`

is an Lwt promise that resolves to the number of files and sub-nodes stored under `k`

in `t`

.

It is equivalent to `let+ l = list t k in List.length l`

but has a constant-time complexity.

### Setters

`add t k v`

is an Lwt promise that resolves to `c`

such that:

`k`

is bound to`v`

in`c`

;- and
`c`

is similar to`t`

otherwise.

If `k`

was already bound in `t`

to a value that is physically equal to `v`

, the result of the function is a promise that resolves to `t`

. Otherwise, the previous binding of `k`

in `t`

disappears.

`remove t k v`

is an Lwt promise that resolves to `c`

such that:

`k`

is unbound in`c`

;- and
`c`

is similar to`t`

otherwise.

### Folding

```
val fold :
?depth:depth ->
tree ->
key ->
order:[ `Sorted | `Undefined ] ->
init:'a ->
f:(key -> tree -> 'a -> 'a Lwt.t) ->
'a Lwt.t
```

`fold ?depth t root ~order ~init ~f`

recursively folds over the trees and values of `t`

. The `f`

callbacks are called with a key relative to `root`

. `f`

is never called with an empty key for values; i.e., folding over a value is a no-op.

The depth is 0-indexed. If `depth`

is set (by default it is not), then `f`

is only called when the conditions described by the parameter is true:

`Eq d`

folds over nodes and values of depth exactly`d`

.`Lt d`

folds over nodes and values of depth strictly less than`d`

.`Le d`

folds over nodes and values of depth less than or equal to`d`

.`Gt d`

folds over nodes and values of depth strictly more than`d`

.`Ge d`

folds over nodes and values of depth more than or equal to`d`

.

If `order`

is ``Sorted`

(the default), the elements are traversed in lexicographic order of their keys. For large nodes, it is memory-consuming, use ``Undefined`

for a more memory efficient `fold`

.

### Configuration

`val is_empty : tree -> bool`

`is_empty t`

is true iff `t`

is `empty _`

.

`to_value t`

is an Lwt promise that resolves to `Some v`

if `t`

is a leaf tree and `None`

otherwise. It is equivalent to ```
find t
[]
```

.

`of_value _ v`

is an Lwt promise that resolves to the leaf tree `v`

. Is is equivalent to `add (empty _) [] v`

.

`val hash : tree -> Tezos_base.TzPervasives.Context_hash.t`

`hash t`

is `t`

's Merkle hash.

### Caches

`val clear : ?depth:int -> tree -> unit`

`clear ?depth t`

clears all caches in the tree `t`

for subtrees with a depth higher than `depth`

. If `depth`

is not set, all of the subtrees are cleared.

`val pp : Format.formatter -> tree -> unit`

`pp`

is the pretty-printer for trees.

### Data Encoding

The type for in-memory, raw contexts.

`val raw_encoding : raw Tezos_base.TzPervasives.Data_encoding.t`

`raw_encoding`

is the data encoding for raw trees.

`to_raw t`

is an Lwt promise that resolves to a raw tree equivalent to `t`

.

`unshallow t`

is the tree equivalent to `t`

but with all subtrees evaluated, i.e. without "reference" nodes. Concretely, it means that no node in `t`

contains just an in-memory hash, but the actual value instead.

`val is_shallow : tree -> bool`

`val kinded_key : tree -> kinded_key option`