sig
  type t
  val dummy : t
  val name : t -> string
  val get_from_name : string -> t
  val add_dependency : t -> t -> unit
  val equal : t -> t -> bool
  val compare : t -> t -> int
  val hash : t -> int
  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_some_projects :
        (Project.project -> bool) -> Project.Computation.INPUT.t -> bool
    end
  module type INFO =
    sig val name : string val dependencies : Project.t list end
  module type MINIMAL_OUTPUT =
    sig
      val self : Project.t
      val select :
        Kind.how ->
        Project.Computation.selection -> Project.Computation.selection
      val depend : Project.t -> unit
      val name : string
    end
  module type OUTPUT =
    sig
      val self : t
      val select : Kind.how -> selection -> selection
      val depend : t -> unit
      val name : string
      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 howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
    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_some_projects : (project -> bool) -> t -> bool
                 end->
        functor (Info : INFO->
          sig
            val self : t
            val select : Kind.how -> selection -> selection
            val depend : t -> unit
            val name : string
            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 descr : Unmarshal.t
                val copy : t -> t
                val name : string
                val register_comparable :
                  ?compare:(t -> t -> int) ->
                  ?equal:(t -> t -> bool) -> ?hash:(t -> int) -> unit -> unit
                val is_comparable_set : unit -> bool
                val hash : t -> int
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val mem_project : ((project -> bool) -> t -> bool) option ref
              end
            val howto_marshal :
              (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
          end
  module Dynamic :
    functor
      (Local : sig val restore : Project.t -> Project.project -> unit end->
      functor (Info : INFO->
        sig
          val add_dependency : Project.t -> Project.t -> unit
          val remove_computation : reset:bool -> Project.t -> unit
          val self : Project.t
          module Register :
            functor (State : sig val clear : Project.project -> unit end->
              functor (Info : INFO-> MINIMAL_OUTPUT
        end
  val dump_dependencies :
    ?only:Project.Computation.selection ->
    ?except:Project.Computation.selection -> string -> unit
  val dump_dynamic_dependencies :
    ?only:Project.Computation.selection ->
    ?except:Project.Computation.selection -> string -> unit
end