Module Make_internal.Val

type key = key
include Irmin.Node.Generic_key.S with type node_key = key and type contents_key = key with type hash = hash with type metadata = Snapshot.metadata with type step = Node.step

Node values

type t

The type for node values.

val t : t Irmin.Type.t
type metadata = Snapshot.metadata

The type for node metadata.

val metadata_t : metadata Irmin.Type.t
type contents_key = key

The type for contents keys.

val contents_key_t : contents_key Irmin.Type.t
type node_key = key

The type for node keys.

val node_key_t : node_key Irmin.Type.t
type step = Node.step

The type for steps between nodes.

val step_t : step Irmin.Type.t
type value = [
  1. | `Node of node_key
  2. | `Contents of contents_key * metadata
]

The type for either (node) keys or (contents) keys combined with their metadata.

val value_t : value Irmin.Type.t
type hash = hash

The type of hashes of values.

val hash_t : hash Irmin.Type.t
val of_list : (step * value) list -> t

of_list l is the node n such that list n = l.

val list : ?offset:int -> ?length:int -> ?cache:bool -> t -> (step * value) list

list t is the contents of t. offset and length are used to paginate results.

val of_seq : (unit -> (step * value) Stdlib__Seq.node) -> t

of_seq s is the node n such that seq n = s.

val seq : ?offset:int -> ?length:int -> ?cache:bool -> t -> unit -> (step * value) Stdlib__Seq.node

seq t is the contents of t. offset and length are used to paginate results.

See caching for an explanation of the cache parameter

val empty : unit -> t

empty () is the empty node.

val is_empty : t -> bool

is_empty t is true iff t is empty.

val hash_exn : ?force:bool -> t -> hash

hash_exn t is the hash of t.

Another way of computing it is Hash.Typed(Hash)(Node).hash t which computes the pre-hash of t before hashing it using Hash. hash_exn might be faster because the it may be optimised (e.g. it may use caching).

hash_exn t is hash_exn ~force:true t which is not expected to raise an exception. hash_exn ~force:false t will raise Not_found if the hash requires IOs to be computed.

val clear : t -> unit

Cleanup internal caches.

val find : ?cache:bool -> t -> step -> value option

find t s is the value associated with s in t.

A node can point to user-defined contents. The edge between the node and the contents is labeled by a step.

See caching for an explanation of the cache parameter

val add : t -> step -> value -> t

add t s v is the node where find t v is Some s but is similar to t otherwise.

val remove : t -> step -> t

remove t s is the node where find t s is None but is similar to t otherwise.

module Metadata : Irmin.Metadata.S with type t = metadata

Metadata functions.

caching

cache regulates the caching behaviour regarding the node's internal data which may be lazily loaded from the backend, depending on the node implementation.

cache defaults to true which may greatly reduce the IOs and the runtime but may also increase the memory consumption.

cache = false doesn't replace a call to clear, it only prevents the storing of new data, it doesn't discard the existing one.

Recursive Nodes

Some Node implementations (like irmin-pack's inodes) can represent a node as a set of nodes. One operation on such "high-level" node corresponds to a sequence of recursive calls to the underlying "lower-level" nodes. Note: theses effects are not in the Lwt monad on purpose (so Tree.hash and Tree.equal are not in the Lwt monad as well).

type effect := expected_depth:int -> node_key -> t option

The type for read effects.

val with_handler : (effect -> effect) -> t -> t

with_handler f replace the current effect handler h by f h. f h will be called for all the recursive read effects that are required by recursive operations on nodes. .

type head := [
  1. | `Node of (step * value) list
  2. | `Inode of int * (int * hash) list
]
val head : t -> head

Reveal the shallow internal structure of the node.

Only hashes and not keys are revealed in the `Inode case, this is because these inodes might not be keyed yet.

merging

val merge : contents:contents_key option Irmin.Merge.t -> node:node_key option Irmin.Merge.t -> t Irmin.Merge.t

merge is the merge function for nodes.

exception Dangling_hash of {
  1. context : string;
  2. hash : hash;
}
val pred : t -> (step option * [ `Node of node_key | `Inode of node_key | `Contents of contents_key ]) list
val nb_children : t -> int
val recompute_hash : t -> hash

Recompute hash for inodes, used in eager integrity checks.

val of_raw : (expected_depth:int -> key -> Raw.t option) -> Raw.t -> t
val to_raw : t -> Raw.t
val save : ?allow_non_root:bool -> add:(hash -> Raw.t -> key) -> index:(hash -> key option) -> mem:(key -> bool) -> t -> key
val stable : t -> bool
val length : t -> int
val index : depth:int -> step -> int
val integrity_check : t -> bool

Checks the integrity of an inode.

module Concrete : sig ... end
val to_concrete : t -> Concrete.t

to_concrete t is the concrete inode tree equivalent to t.

val of_concrete : Concrete.t -> (t, Concrete.error) Stdlib.result

of_concrete c is Ok t iff c and t are equivalent.

The result is Error e when a subtree tree of c has an integrity error.

module Portable : sig ... end
val of_snapshot : Snapshot.inode -> index:(hash -> key) -> (expected_depth:int -> key -> Raw.t option) -> t