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