S.Val
type key = key
include Irmin.Node.Generic_key.S
with type node_key = key
and type contents_key = key
with type t = value
with type hash = Hash.t
type t = value
The type for node values.
val t : t Irmin.Type.t
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
val step_t : step Irmin.Type.t
The type for either (node) keys or (contents) keys combined with their metadata.
val value_t : value Irmin.Type.t
type hash = Hash.t
The type of hashes of values.
val hash_t : hash Irmin.Type.t
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 : Irmin.Metadata.S with type t = metadata
Metadata functions.
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.
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).
val with_handler : (read_effect -> read_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. .
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.
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.
val pred :
t ->
(step option
* [ `Node of node_key | `Inode of node_key | `Contents of contents_key ])
list
val nb_children : t -> int