package irmin
Val
provides base functions for node values.
Node values
type t = value
The type for node values.
type metadata = Metadata.t
The type for node metadata.
type contents_key = Contents.key
The type for contents keys.
val contents_key_t : contents_key Type.t
type node_key = key
The type for node keys.
type step = Path.step
The type for steps between nodes.
The type for either (node) keys or (contents) keys combined with their metadata.
type hash = hash
The type of hashes of values.
list t
is the contents of t
. offset
and length
are used to paginate results.
of_seq s
is the node n
such that seq n = s
.
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 length : t -> int
length t
is the number of entries in t
.
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.
add t s v
is the node where find t v
is Some s
but is similar to t
otherwise.
remove t s
is the node where find t s
is None
but is similar to t
otherwise.
module Metadata : 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).
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. .
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
merge
is the merge function for nodes.