# package octez-libs

### 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 ->
t ->
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`

.