`Schema.Node`

`module Contents_key : Irmin.Key.S with type hash = Hash.t`

`module Node_key : Irmin.Key.S with type hash = Hash.t`

`val t : t Irmin.Type.t`

`type metadata = Metadata.t`

The type for node metadata.

`val metadata_t : metadata Irmin.Type.t`

`type contents_key = Contents_key.t`

The type for contents keys.

`val contents_key_t : contents_key Irmin.Type.t`

`type node_key = Node_key.t`

The type for node keys.

`val node_key_t : node_key Irmin.Type.t`

`type step = Path.step`

The type for steps between nodes.

`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).

`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.