Module `Irmin_fs_unix.Make`

Parameters

module Schema : sig ... end

Signature

module Schema : sig ... end

type repo

type t

type step = Schema.Path.step

val step_t : step Irmin__.Type.t

type path = Schema.Path.t

val path_t : path Irmin__.Type.t

type metadata = Schema.Metadata.t

val metadata_t : metadata Irmin__.Type.t

type contents = Schema.Contents.t

val contents_t : contents Irmin__.Type.t

type node

val node_t : node Irmin__.Type.t

type tree

val tree_t : tree Irmin__.Type.t

type hash = Schema.Hash.t

val hash_t : hash Irmin__.Type.t

type commit

val commit_t : repo -> commit Irmin__.Type.t

type branch = Schema.Branch.t

val branch_t : branch Irmin__.Type.t

type slice

val slice_t : slice Irmin__.Type.t

type info = Schema.Info.t

val info_t : info Irmin__.Type.t

type lca_error = [

| `Max_depth_reached
| `Too_many_lcas

]

val lca_error_t : lca_error Irmin__.Type.t

type ff_error = [

| `Max_depth_reached
| `No_change
| `Rejected
| `Too_many_lcas

]

val ff_error_t : ff_error Irmin__.Type.t

module Info : sig ... end

type contents_key = (Schema.Hash.t, Schema.Contents.t) contents_key

val contents_key_t : contents_key Irmin__.Type.t

type node_key = Schema.Hash.t node_key

val node_key_t : node_key Irmin__.Type.t

type commit_key = Schema.Hash.t commit_key

val commit_key_t : commit_key Irmin__.Type.t

module Repo : sig ... end

val empty : repo -> t Lwt.t

val main : repo -> t Lwt.t

val of_branch : repo -> branch -> t Lwt.t

val of_commit : commit -> t Lwt.t

val repo : t -> repo

val tree : t -> tree Lwt.t

module Status : sig ... end

val status : t -> Status.t

module Head : sig ... end

module Hash : sig ... end

module Commit : sig ... end

module Contents : sig ... end

module Tree : sig ... end

val kind : t -> path -> [ `Contents | `Node ] option Lwt.t

val list : t -> path -> (step * tree) list Lwt.t

val mem : t -> path -> bool Lwt.t

val mem_tree : t -> path -> bool Lwt.t

val find_all : t -> path -> (contents * metadata) option Lwt.t

val find : t -> path -> contents option Lwt.t

val get_all : t -> path -> (contents * metadata) Lwt.t

val get : t -> path -> contents Lwt.t

val find_tree : t -> path -> tree option Lwt.t

val get_tree : t -> path -> tree Lwt.t

val key : 
  t ->
  path ->
  [ `Contents of contents_key | `Node of node_key ] option Lwt.t

val hash : t -> path -> hash option Lwt.t

type write_error = [

| `Conflict of string
| `Test_was of tree option
| `Too_many_retries of int

]

val write_error_t : write_error Irmin__.Type.t

val set : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  contents ->
  (unit, write_error) result Lwt.t

val set_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  contents ->
  unit Lwt.t

val set_tree : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  tree ->
  (unit, write_error) result Lwt.t

val set_tree_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  tree ->
  unit Lwt.t

val remove : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  (unit, write_error) result Lwt.t

val remove_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  unit Lwt.t

val test_and_set : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  test:contents option ->
  set:contents option ->
  (unit, write_error) result Lwt.t

val test_and_set_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  test:contents option ->
  set:contents option ->
  unit Lwt.t

val test_and_set_tree : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  test:tree option ->
  set:tree option ->
  (unit, write_error) result Lwt.t

val test_and_set_tree_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  test:tree option ->
  set:tree option ->
  unit Lwt.t

val test_set_and_get : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:(unit -> info) ->
  t ->
  path ->
  test:contents option ->
  set:contents option ->
  (commit option, write_error) result Lwt.t

val test_set_and_get_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:(unit -> info) ->
  t ->
  path ->
  test:contents option ->
  set:contents option ->
  commit option Lwt.t

val test_set_and_get_tree : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:(unit -> info) ->
  t ->
  path ->
  test:tree option ->
  set:tree option ->
  (commit option, write_error) result Lwt.t

val test_set_and_get_tree_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:(unit -> info) ->
  t ->
  path ->
  test:tree option ->
  set:tree option ->
  commit option Lwt.t

val merge : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  old:contents option ->
  t ->
  path ->
  contents option ->
  (unit, write_error) result Lwt.t

val merge_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  old:contents option ->
  t ->
  path ->
  contents option ->
  unit Lwt.t

val merge_tree : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  old:tree option ->
  t ->
  path ->
  tree option ->
  (unit, write_error) result Lwt.t

val merge_tree_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  old:tree option ->
  t ->
  path ->
  tree option ->
  unit Lwt.t

val with_tree : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  ?strategy:[ `Merge | `Set | `Test_and_set ] ->
  info:Info.f ->
  t ->
  path ->
  (tree option -> tree option Lwt.t) ->
  (unit, write_error) result Lwt.t

val with_tree_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  ?strategy:[ `Merge | `Set | `Test_and_set ] ->
  info:Info.f ->
  t ->
  path ->
  (tree option -> tree option Lwt.t) ->
  unit Lwt.t

val clone : src:t -> dst:branch -> t Lwt.t

type watch

val watch : 
  t ->
  ?init:commit ->
  (commit Irmin__.Diff.t -> unit Lwt.t) ->
  watch Lwt.t

val watch_key : 
  t ->
  path ->
  ?init:commit ->
  ((commit * tree) Irmin__.Diff.t -> unit Lwt.t) ->
  watch Lwt.t

val unwatch : watch -> unit Lwt.t

type !'a merge =
  info:Info.f ->
  ?max_depth:int ->
  ?n:int ->
  'a ->
  (unit, Irmin__.Merge.conflict) result Lwt.t

val merge_into : into:t -> t merge

val merge_with_branch : t -> branch merge

val merge_with_commit : t -> commit merge

val lcas : 
  ?max_depth:int ->
  ?n:int ->
  t ->
  t ->
  (commit list, lca_error) result Lwt.t

val lcas_with_branch : 
  t ->
  ?max_depth:int ->
  ?n:int ->
  branch ->
  (commit list, lca_error) result Lwt.t

val lcas_with_commit : 
  t ->
  ?max_depth:int ->
  ?n:int ->
  commit ->
  (commit list, lca_error) result Lwt.t

module History : sig ... end

val history : 
  ?depth:int ->
  ?min:commit list ->
  ?max:commit list ->
  t ->
  History.t Lwt.t

val last_modified : ?depth:int -> ?n:int -> t -> path -> commit list Lwt.t

module Branch : sig ... end

module Path : sig ... end

module Metadata : sig ... end

module Backend : sig ... end

type Irmin__.Remote.t +=

| E of Backend.Remote.endpoint

val of_backend_node : repo -> Backend.Node.value -> node

val to_backend_node : node -> Backend.Node.value Lwt.t

val to_backend_portable_node : node -> Backend.Node_portable.t Lwt.t

val to_backend_commit : commit -> Backend.Commit.value

val of_backend_commit : 
  repo ->
  Backend.Commit.Key.t ->
  Backend.Commit.value ->
  commit

val save_contents : 
  [> Irmin__.Import.write ] Backend.Contents.t ->
  contents ->
  contents_key Lwt.t

val save_tree : 
  ?clear:bool ->
  repo ->
  [> Irmin__.Import.write ] Backend.Contents.t ->
  [> Irmin__.Import.read_write ] Backend.Node.t ->
  tree ->
  [ `Contents of contents_key | `Node of node_key ] Lwt.t

val master : repo -> t Lwt.t

deprecated Use `main` instead.

Install

Dune Dependency

Authors

Maintainers

Sources

doc/irmin-fs.unix/Irmin_fs_unix/Make/index.html

Module `Irmin_fs_unix.Make`

Parameters

Signature

package irmin-fs

Install

Dune Dependency

Authors

Maintainers

Sources

doc/irmin-fs.unix/Irmin_fs_unix/Make/index.html

Module Irmin_fs_unix.Make

Parameters

Signature

Module `Irmin_fs_unix.Make`