sig
  type t
  type project = Project.t
  val ty : Project.t Type.t
  val dummy : Project.t
  module type KIND =
    sig
      type t
      val dummy : Project.KIND.t
      val name : Project.KIND.t -> string
      val add_dependency : Project.KIND.t -> Project.KIND.t -> unit
    end
  val identity : '-> 'a
  val is_identity : ('-> 'a) -> bool
  module Datatype :
    sig
      module type INPUT =
        sig
          type t
          val rehash : Project.Datatype.INPUT.t -> Project.Datatype.INPUT.t
          val descr : Unmarshal.t
          val copy : Project.Datatype.INPUT.t -> Project.Datatype.INPUT.t
          val name : string
        end
      module type S =
        sig
          type t
          val rehash : t -> t
          val descr : Unmarshal.t
          val copy : t -> t
          val name : string
          val register_comparable :
            ?compare:(Project.t -> Project.t -> int) ->
            ?equal:(Project.t -> Project.t -> bool) ->
            ?hash:(Project.t -> int) ->
            ?physical_hash:(Project.t -> int) -> unit -> unit
          val is_comparable_set : unit -> bool
          val hash : Project.t -> int
          val physical_hash : Project.t -> int
          val equal : Project.t -> Project.t -> bool
          val compare : Project.t -> Project.t -> int
          val contain_project :
            (Project.project -> Project.t -> bool) option Pervasives.ref
        end
      module Register :
        functor (Datatype : INPUT->
          sig
            type t = Datatype.t
            val rehash : t -> t
            val descr : Unmarshal.t
            val copy : t -> t
            val name : string
            val register_comparable :
              ?compare:(t -> t -> int) ->
              ?equal:(t -> t -> bool) ->
              ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
            val is_comparable_set : unit -> bool
            val hash : t -> int
            val physical_hash : t -> int
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val contain_project : (project -> t -> bool) option ref
          end
      module Imperative :
        functor
          (X : sig
                 type t
                 val copy :
                   Project.Datatype.Imperative.t ->
                   Project.Datatype.Imperative.t
                 val name : string
               end->
          sig
            type t = X.t
            val rehash : t -> t
            val descr : Unmarshal.t
            val copy : t -> t
            val name : string
            val register_comparable :
              ?compare:(t -> t -> int) ->
              ?equal:(t -> t -> bool) ->
              ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
            val is_comparable_set : unit -> bool
            val hash : t -> int
            val physical_hash : t -> int
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val contain_project : (project -> t -> bool) option ref
          end
      module Persistent :
        functor (X : sig type t val name : string end->
          sig
            type t = X.t
            val rehash : t -> t
            val descr : Unmarshal.t
            val copy : t -> t
            val name : string
            val register_comparable :
              ?compare:(t -> t -> int) ->
              ?equal:(t -> t -> bool) ->
              ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
            val is_comparable_set : unit -> bool
            val hash : t -> int
            val physical_hash : t -> int
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val contain_project : (project -> t -> bool) option ref
          end
      module Own :
        sig
          type t = project
          val rehash : t -> t
          val descr : Unmarshal.t
          val copy : t -> t
          val name : string
          val register_comparable :
            ?compare:(t -> t -> int) ->
            ?equal:(t -> t -> bool) ->
            ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
          val is_comparable_set : unit -> bool
          val hash : t -> int
          val physical_hash : t -> int
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val contain_project : (project -> t -> bool) option ref
        end
      val extend_name : string -> string -> string
      val extend_name2 : string -> string -> string -> string
      val extend_name3 : string -> string -> string -> string -> string
    end
  module Computation :
    sig
      type t
      val dummy : t
      val name : t -> string
      val add_dependency : t -> t -> unit
      type selection
      module type INPUT =
        sig
          type t
          val create : unit -> Project.Computation.INPUT.t
          val clear : Project.Computation.INPUT.t -> unit
          val get : unit -> Project.Computation.INPUT.t
          val set : Project.Computation.INPUT.t -> unit
          val clear_if_project :
            Project.project -> Project.Computation.INPUT.t -> bool
        end
      module type INFO =
        sig val name : string val dependencies : Project.t list end
      module type OUTPUT =
        sig
          val self : Project.t
          val select :
            Kind.how ->
            Project.Computation.selection -> Project.Computation.selection
          val depend : Project.t -> unit
          val mark_as_computed : ?project:Project.project -> unit -> unit
          val is_computed : ?project:Project.project -> unit -> bool
          val do_not_save : unit -> unit
          module Datatype : Datatype.S
          val name : string
        end
      module Register :
        functor (Datatype : Datatype.S->
          functor
            (State : sig
                       type t = Datatype.t
                       val create : unit -> t
                       val clear : t -> unit
                       val get : unit -> t
                       val set : t -> unit
                       val clear_if_project : project -> t -> bool
                     end->
            functor (Info : INFO->
              sig
                val self : t
                val select : Kind.how -> selection -> selection
                val depend : t -> unit
                val mark_as_computed : ?project:project -> unit -> unit
                val is_computed : ?project:project -> unit -> bool
                val do_not_save : unit -> unit
                module Datatype :
                  sig
                    type t = Datatype.t
                    val rehash : t -> t
                    val descr : Unmarshal.t
                    val copy : t -> t
                    val name : string
                    val register_comparable :
                      ?compare:(t -> t -> int) ->
                      ?equal:(t -> t -> bool) ->
                      ?hash:(t -> int) ->
                      ?physical_hash:(t -> int) -> unit -> unit
                    val is_comparable_set : unit -> bool
                    val hash : t -> int
                    val physical_hash : t -> int
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    val contain_project : (project -> t -> bool) option ref
                  end
                val name : string
              end
      val dump_dependencies :
        ?only:Project.Computation.selection ->
        ?except:Project.Computation.selection -> string -> unit
    end
  module Selection :
    sig
      type kind = Computation.t
      type t = Computation.selection
      val ty : t Type.t
      val empty : t
      val is_empty : t -> bool
      val add : kind -> Kind.how -> t -> t
      val singleton : kind -> Kind.how -> t
      val remove : kind -> t -> t
      val iter : (kind -> Kind.how -> unit) -> t -> unit
      val fold : (kind -> Kind.how -> '-> 'a) -> t -> '-> 'a
    end
  val create : string -> Project.t
  val register_create_hook : (Project.t -> unit) -> unit
  exception NoProject
  val current : unit -> Project.t
  val is_current : Project.t -> bool
  val iter_on_projects : (Project.t -> unit) -> unit
  val find_all : string -> Project.t list
  val clear_all : unit -> unit
  exception IOError of string
  val save :
    ?only:Project.Selection.t ->
    ?except:Project.Selection.t -> ?project:Project.t -> string -> unit
  val load :
    ?only:Project.Selection.t ->
    ?except:Project.Selection.t -> name:string -> string -> Project.t
  val save_all : string -> unit
  val load_all : string -> unit
  val register_before_load_hook : (unit -> unit) -> unit
  val register_after_load_hook : (unit -> unit) -> unit
  val name : Project.t -> string
  val unique_name : Project.t -> string
  val from_unique_name : string -> Project.t
  val set_current :
    ?on:bool ->
    ?only:Project.Selection.t ->
    ?except:Project.Selection.t -> Project.t -> unit
  val register_after_set_current_hook :
    user_only:bool -> (Project.t -> unit) -> unit
  val on :
    ?only:Project.Selection.t ->
    ?except:Project.Selection.t -> Project.t -> ('-> 'b) -> '-> 'b
  val copy :
    ?only:Project.Selection.t ->
    ?except:Project.Selection.t -> ?src:Project.t -> Project.t -> unit
  val create_by_copy :
    ?only:Project.Selection.t ->
    ?except:Project.Selection.t -> ?src:Project.t -> string -> Project.t
  val create_by_copy_hook : (Project.t -> Project.t -> unit) -> unit
  val clear :
    ?only:Project.Selection.t ->
    ?except:Project.Selection.t -> ?project:Project.t -> unit -> unit
  val register_todo_on_clear : (unit -> unit) -> unit
  exception Cannot_remove of string
  val remove : ?project:Project.t -> unit -> unit
  val compare : Project.t -> Project.t -> int
  val equal : Project.t -> Project.t -> bool
  val hash : Project.t -> int
  val rehash : Project.t -> Project.t
  module Undo :
    sig
      val breakpoint : unit -> unit
      val restore : unit -> unit
      val clear_breakpoint : unit -> unit
    end
end