# Module `Mirage_kv_unix`

Loopback implementation of the FS signature.

`type error`

=`[`

`|`

`Mirage_kv.error`

`|`

``Storage_error of Mirage_kv.Key.t * string`

`]`

`type write_error`

=`[`

`|`

`Mirage_kv.write_error`

`|`

``Storage_error of Mirage_kv.Key.t * string`

`|`

``Key_exists of Mirage_kv.Key.t`

`]`

`include Mirage_kv_lwt.RW with type error := error and type write_error := write_error`

`include Mirage_kv.RO`

`and error`

= private`[>`

`|`

`Mirage_kv.error`

`]`

The type for errors.

`include Mirage_device.S`

`type key`

`= Mirage_kv.Key.t`

The type for keys.

`val exists : t -> key -> ([ `Value | `Dictionary ] option, error) Stdlib.result io`

`exists t k`

is`Some `Value`

if`k`

is bound to a value in`t`

,`Some `Dictionary`

if`k`

is a prefix of a valid key in`t`

and`None`

if no key with that prefix exists in`t`

.`exists`

answers two questions: does the key exist and is it referring to a value or a dictionary.An error occurs when the underlying storage layer fails.

`val get : t -> key -> (value, error) Stdlib.result io`

`get t k`

is the value bound to`k`

in`t`

.The result is

`Error (`Value_expected k)`

if`k`

refers to a dictionary in`t`

.

`val list : t -> key -> ((string * [ `Value | `Dictionary ]) list, error) Stdlib.result io`

`list t k`

is the list of entries and their types in the dictionary referenced by`k`

in`t`

.The result is

`Error (`Dictionary_expected k)`

if`k`

refers to a value in`t`

.

`val last_modified : t -> key -> (int * int64, error) Stdlib.result io`

`last_modified t k`

is the last time the value bound to`k`

in`t`

has been modified.The modification time

`(d, ps)`

is a span for the signed POSIX picosecond span`d`

* 86_400e12 +`ps`

.`d`

is a signed number of POSIX days and`ps`

a number of picoseconds in the range [`0`

;`86_399_999_999_999_999L`

].When the value bound to

`k`

is a dictionary, the modification time is the latest modification of all entries in that dictionary. This behaviour is only one level deep and not recursive.

`val digest : t -> key -> (string, error) Stdlib.result io`

`digest t k`

is the unique digest of the value bound to`k`

in`t`

.When the value bound to

`k`

is a dictionary, the digest is a unique and deterministic digest of its entries.

`and write_error`

= private`[>`

`|`

`Mirage_kv.write_error`

`]`

The type for write errors.

`val pp_write_error : write_error Fmt.t`

The pretty-printer for

`pp_write_error`

.

`val set : t -> key -> value -> (unit, write_error) Stdlib.result io`

`set t k v`

replaces the binding`k -> v`

in`t`

.Durability is guaranteed unless

`set`

is run inside an enclosing`batch`

operation, where durability will be guaranteed at the end of the batch.

`val remove : t -> key -> (unit, write_error) Stdlib.result io`

`remove t k`

removes any binding of`k`

in`t`

. If`k`

was bound to a dictionary, the full dictionary will be removed.Durability is guaranteed unless

`remove`

is run inside an enclosing`batch`

operation, where durability will be guaranteed at the end of the batch.

`val batch : t -> ?retries:int -> (t -> 'a io) -> 'a io`

`batch t f`

run`f`

in batch. Ensure the durability of operations.Since a batch is applied at once, the readings inside a batch will return the state before the entire batch. Concurrent operations will not affect other ones executed during the batch.

Batch applications can fail to apply if other operations are happening concurrently. In case of failure,

`f`

will run again with the most recent version of`t`

. The result is`Error `Too_many_retries`

if`f`

is run for more then`retries`

attemps (default is`13`

).