Irmin, a distributed database that follows the same design principles as Git
Module Irmin . Backend . Conf

Configuration converters

A configuration converter transforms a string value to an OCaml value and vice-versa.


type 'a key

The type for configuration keys whose lookup value is 'a.

type k =
| K : 'a key -> k
module Spec : sig ... end
val key : ?docs:string -> ?docv:string -> ?doc:string -> spec:Spec.t -> string -> 'a Type.t -> 'a -> 'a key

key ~docs ~docv ~doc ~spec name conv default is a configuration key named name that maps to value default by default. It will be associated with the config grouping spec. conv is used to convert key values provided by end users.

docs is the title of a documentation section under which the key is documented. doc is a short documentation string for the key, this should be a single sentence or paragraph starting with a capital letter and ending with a dot. docv is a meta-variable for representing the values of the key (e.g. "BOOL" for a boolean).

  • raises Invalid_argument

    if the key name is not made of a sequence of ASCII lowercase letter, digit, dash or underscore.

    Warning. No two keys should share the same name as this may lead to difficulties in the UI.

val name : 'a key -> string

The key name.

val ty : 'a key -> 'a Type.t

tc k is k's converter.

val default : 'a key -> 'a

default k is k's default value.

val doc : 'a key -> string option

doc k is k's documentation string (if any).

val docv : 'a key -> string option

docv k is k's value documentation meta-variable (if any).

val docs : 'a key -> string option

docs k is k's documentation section (if any).

val root : Spec.t -> string key

Default --root=ROOT argument.


type t

The type for configurations.

val spec : t -> Spec.t

spec c is the specification associated with c

val empty : Spec.t -> t

empty spec is an empty configuration.

val singleton : Spec.t -> 'a key -> 'a -> t

singleton spec k v is the configuration where k maps to v.

val is_empty : t -> bool

is_empty c is true iff c is empty.

val mem : t -> 'a key -> bool

mem c k is true iff k has a mapping in c.

val add : t -> 'a key -> 'a -> t

add c k v is c with k mapping to v.

val rem : t -> 'a key -> t

rem c k is c with k unbound.

val union : t -> t -> t

union r s is the union of the configurations r and s.

val find : t -> 'a key -> 'a option

find c k is k's mapping in c, if any.

val get : t -> 'a key -> 'a

get c k is k's mapping in c.

Raises. Not_found if k is not bound in d.

val keys : t -> k Seq.t

keys c is a sequence of all keys present in c

val with_spec : t -> Spec.t -> t

with_spec t s is the config t with spec s

val verify : t -> t

verify t is an identity function that ensures all keys match the spec

Raises. Invalid_argument if t contains invalid keys

Built-in value converters

val uri : Uri.t Type.t

uri converts values with Uri.of_string.

val find_root : t -> string option

find_root c is root's mapping in c, if any.