sig
  val apply_once :
    string ->
    Project.Computation.t list ->
    (unit -> unit) -> (unit -> unit) * Project.Computation.t
  module type REF_INPUT =
    sig
      type 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.project -> t -> bool) option ref
      val default : unit -> t
    end
  module type REF_OUTPUT =
    sig
      val self : Project.Computation.t
      val select :
        Kind.how ->
        Project.Computation.selection -> Project.Computation.selection
      val depend : Project.Computation.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 : Project.Datatype.S
      val name : string
      type data
      val set : Computation.REF_OUTPUT.data -> unit
      val get : unit -> Computation.REF_OUTPUT.data
      val clear : unit -> unit
    end
  module Ref :
    functor (Data : REF_INPUT->
      functor (Info : Signature.NAME_DPDS->
        sig
          val self : Project.Computation.t
          val select :
            Kind.how ->
            Project.Computation.selection -> Project.Computation.selection
          val depend : Project.Computation.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 : Project.Datatype.S
          val name : string
          type data = Data.t
          val set : data -> unit
          val get : unit -> data
          val clear : unit -> unit
        end
  module type OPTION_REF_OUTPUT =
    sig
      val self : Project.Computation.t
      val select :
        Kind.how ->
        Project.Computation.selection -> Project.Computation.selection
      val depend : Project.Computation.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 : Project.Datatype.S
      val name : string
      type data
      val set : data -> unit
      val get : unit -> data
      val clear : unit -> unit
      val memo : ?change:(data -> data) -> (unit -> data) -> data
      val map : (data -> data) -> data option
      val may : (data -> unit) -> unit
      val get_option : unit -> data option
    end
  module OptionRef :
    functor (Data : Project.Datatype.S->
      functor (Info : Signature.NAME_DPDS->
        sig
          val self : Project.Computation.t
          val select :
            Kind.how ->
            Project.Computation.selection -> Project.Computation.selection
          val depend : Project.Computation.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 : Project.Datatype.S
          val name : string
          type data = Data.t
          val set : data -> unit
          val get : unit -> data
          val clear : unit -> unit
          val memo : ?change:(data -> data) -> (unit -> data) -> data
          val map : (data -> data) -> data option
          val may : (data -> unit) -> unit
          val get_option : unit -> data option
        end
  module type HASHTBL =
    sig
      type key
      type 'a t
      val create : int -> 'a t
      val iter : (key -> '-> unit) -> 'a t -> unit
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val add : 'a t -> key -> '-> unit
      val replace : 'a t -> key -> '-> unit
      val length : 'a t -> int
      val find_all : 'a t -> key -> 'a list
      val clear : 'a t -> unit
      val find : 'a t -> key -> 'a
      val remove : 'a t -> key -> unit
      val mem : 'a t -> key -> bool
    end
  module type HASHTBL_OUTPUT =
    sig
      val self : Project.Computation.t
      val select :
        Kind.how ->
        Project.Computation.selection -> Project.Computation.selection
      val depend : Project.Computation.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 : Project.Datatype.S
      val name : string
      type key
      type data
      val replace :
        Computation.HASHTBL_OUTPUT.key ->
        Computation.HASHTBL_OUTPUT.data -> unit
      val add :
        Computation.HASHTBL_OUTPUT.key ->
        Computation.HASHTBL_OUTPUT.data -> unit
      val clear : unit -> unit
      val length : unit -> int
      val iter :
        (Computation.HASHTBL_OUTPUT.key ->
         Computation.HASHTBL_OUTPUT.data -> unit) ->
        unit
      val fold :
        (Computation.HASHTBL_OUTPUT.key ->
         Computation.HASHTBL_OUTPUT.data -> '-> 'a) ->
        '-> 'a
      val memo :
        ?change:(Computation.HASHTBL_OUTPUT.data ->
                 Computation.HASHTBL_OUTPUT.data) ->
        (Computation.HASHTBL_OUTPUT.key -> Computation.HASHTBL_OUTPUT.data) ->
        Computation.HASHTBL_OUTPUT.key -> Computation.HASHTBL_OUTPUT.data
      val find :
        Computation.HASHTBL_OUTPUT.key -> Computation.HASHTBL_OUTPUT.data
      val find_all :
        Computation.HASHTBL_OUTPUT.key ->
        Computation.HASHTBL_OUTPUT.data list
      val unsafe_find :
        Computation.HASHTBL_OUTPUT.key -> Computation.HASHTBL_OUTPUT.data
      val mem : Computation.HASHTBL_OUTPUT.key -> bool
      val remove : Computation.HASHTBL_OUTPUT.key -> unit
    end
  module Make_Hashtbl :
    functor (H : HASHTBL->
      functor (Data : Project.Datatype.S->
        functor (Info : Signature.NAME_SIZE_DPDS->
          sig
            val self : Project.Computation.t
            val select :
              Kind.how ->
              Project.Computation.selection -> Project.Computation.selection
            val depend : Project.Computation.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 : Project.Datatype.S
            val name : string
            type key = H.key
            type data = Data.t
            val replace : key -> data -> unit
            val add : key -> data -> unit
            val clear : unit -> unit
            val length : unit -> int
            val iter : (key -> data -> unit) -> unit
            val fold : (key -> data -> '-> 'a) -> '-> 'a
            val memo : ?change:(data -> data) -> (key -> data) -> key -> data
            val find : key -> data
            val find_all : key -> data list
            val unsafe_find : key -> data
            val mem : key -> bool
            val remove : key -> unit
          end
  module Hashtbl :
    functor (Key : Hashtbl.HashedType->
      functor (Data : Project.Datatype.S->
        functor (Info : Signature.NAME_SIZE_DPDS->
          sig
            val self : Project.Computation.t
            val select :
              Kind.how ->
              Project.Computation.selection -> Project.Computation.selection
            val depend : Project.Computation.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 : Project.Datatype.S
            val name : string
            type key = Key.t
            type data = Data.t
            val replace : key -> data -> unit
            val add : key -> data -> unit
            val clear : unit -> unit
            val length : unit -> int
            val iter : (key -> data -> unit) -> unit
            val fold : (key -> data -> '-> 'a) -> '-> 'a
            val memo : ?change:(data -> data) -> (key -> data) -> key -> data
            val find : key -> data
            val find_all : key -> data list
            val unsafe_find : key -> data
            val mem : key -> bool
            val remove : key -> unit
          end
  module type SET =
    sig
      type elt
      type t
      val empty : Computation.SET.t
      val singleton : Computation.SET.elt -> Computation.SET.t
      val is_empty : Computation.SET.t -> bool
      val add : Computation.SET.elt -> Computation.SET.t -> Computation.SET.t
      val mem : Computation.SET.elt -> Computation.SET.t -> bool
      val fold :
        (Computation.SET.elt -> '-> 'a) -> Computation.SET.t -> '-> 'a
      val iter : (Computation.SET.elt -> unit) -> Computation.SET.t -> unit
    end
  module type SET_REF_OUTPUT =
    sig
      val self : Project.Computation.t
      val select :
        Kind.how ->
        Project.Computation.selection -> Project.Computation.selection
      val depend : Project.Computation.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 : Project.Datatype.S
      val name : string
      type elt
      val add : Computation.SET_REF_OUTPUT.elt -> unit
      val mem : Computation.SET_REF_OUTPUT.elt -> bool
      val is_empty : unit -> bool
      val fold : (Computation.SET_REF_OUTPUT.elt -> '-> 'a) -> '-> 'a
      val iter : (Computation.SET_REF_OUTPUT.elt -> unit) -> unit
    end
  module Make_SetRef :
    functor (Set : SET->
      functor
        (Data : sig
                  type t = Set.elt
                  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.project -> t -> bool) option ref
                end->
        functor (Info : Signature.NAME_DPDS->
          sig
            val self : Project.Computation.t
            val select :
              Kind.how ->
              Project.Computation.selection -> Project.Computation.selection
            val depend : Project.Computation.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 : Project.Datatype.S
            val name : string
            type elt = Data.t
            val add : elt -> unit
            val mem : elt -> bool
            val is_empty : unit -> bool
            val fold : (elt -> '-> 'a) -> '-> 'a
            val iter : (elt -> unit) -> unit
          end
  module SetRef :
    functor (Data : Project.Datatype.S->
      functor (Info : Signature.NAME_DPDS->
        sig
          val self : Project.Computation.t
          val select :
            Kind.how ->
            Project.Computation.selection -> Project.Computation.selection
          val depend : Project.Computation.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 : Project.Datatype.S
          val name : string
          type elt = Data.t
          val add : elt -> unit
          val mem : elt -> bool
          val is_empty : unit -> bool
          val fold : (elt -> '-> 'a) -> '-> 'a
          val iter : (elt -> unit) -> unit
        end
  module type QUEUE =
    sig
      type elt
      val add : Computation.QUEUE.elt -> unit
      val iter : (Computation.QUEUE.elt -> unit) -> unit
      val is_empty : unit -> bool
    end
  module Queue :
    functor (Data : Project.Datatype.S->
      functor (Info : Signature.NAME_DPDS->
        sig
          type elt = Data.t
          val add : elt -> unit
          val iter : (elt -> unit) -> unit
          val is_empty : unit -> bool
        end
  module Project :
    functor (Info : Signature.NAME_DPDS->
      sig
        val self : Project.Computation.t
        val select :
          Kind.how ->
          Project.Computation.selection -> Project.Computation.selection
        val depend : Project.Computation.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 : Project.Datatype.S
        val name : string
        type data = Project.t
        val set : data -> unit
        val get : unit -> data
        val clear : unit -> unit
      end
end