`Contents.Store_indexable`

`Store_indexable`

is like `Store`

but uses an indexable store as a backend (rather than a content-addressable one).

`module S : Indexable.S`

```
include Indexable.S
with type 'a t = 'a S.t
with type key = S.key
with type value = S.value
with type hash = S.hash
```

Read-only stores are store where it is only possible to read existing values.

`type 'a t = 'a S.t`

The type for stores. The `'a`

phantom type carries information about the store mutability.

`type key = S.key`

The type for keys.

`type value = S.value`

The type for raw values.

`val mem : [> Perms.read ] t -> key -> bool Lwt.t`

`mem t k`

is true iff `k`

is present in `t`

.

`val find : [> Perms.read ] t -> key -> value option Lwt.t`

`find t k`

is `Some v`

if `k`

is associated to `v`

in `t`

and `None`

is `k`

is not present in `t`

.

`val close : 'a t -> unit Lwt.t`

`close t`

frees up all the resources associated with `t`

. Any operations run on a closed handle will raise `Closed`

.

`type hash = S.hash`

The type of hashes of `value`

.

`val add : [> Perms.write ] t -> value -> key Lwt.t`

Write the contents of a value to the store, and obtain its key.

`val unsafe_add : [> Perms.write ] t -> hash -> value -> key Lwt.t`

Same as `add`

but allows specifying the value's hash directly. The backend might choose to discard that hash and/or can be corrupt if the hash is not consistent.

`val index : [> Perms.read ] t -> hash -> key option Lwt.t`

Indexing maps the hash of a value to a corresponding key of that value in the store. For stores that are addressed by hashes directly, this is typically `fun _t h -> Lwt.return (Key.of_hash h)`

; for stores with more complex addressing schemes, `index`

may attempt a lookup operation in the store.

In general, indexing is best-effort and reveals no information about the membership of the value in the store. In particular:

`index t hash = Some key`

doesn't guarantee`mem t key`

: the value with hash`hash`

may still be absent from the store;

`index t hash = None`

doesn't guarantee that there is no`key`

such that`mem t key`

and`Key.to_hash key = hash`

: the value may still be present in the store under a key that is not indexed.

```
val batch :
Perms.read t ->
([ Perms.read | Perms.write ] t -> 'a Lwt.t) ->
'a Lwt.t
```

`batch t f`

applies the writes in `f`

in a separate batch. The exact guarantees depend on the implementation.

`val merge : [> Perms.read_write ] t -> key option Merge.t`

`merge t`

lifts the merge functions defined on contents values to contents key. The merge function will: *(i)* read the values associated with the given keys, *(ii)* use the merge function defined on values and *(iii)* write the resulting values into the store to get the resulting key. See `val-S.merge`

.

If any of these operations fail, return ``Conflict`

.

`module Val : sig ... end`