sig
  val apply_once :
    string ->
    Project.Computation.t list ->
    (unit -> unit) -> (unit -> unit) * Project.Computation.t
  module type REF_INPUT =
    sig
      type 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.project -> bool) -> 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 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 : Project.Datatype.S
      val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
      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 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 : Project.Datatype.S
          val howto_marshal :
            (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
          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 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 : Project.Datatype.S
      val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
      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 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 : Project.Datatype.S
          val howto_marshal :
            (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
          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 LIST_REF_OUTPUT =
    sig
      type data_in_list
      val self : Project.Computation.t
      val select :
        Kind.how ->
        Project.Computation.selection -> Project.Computation.selection
      val depend : Project.Computation.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 : Project.Datatype.S
      val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
      type data
      val set : data -> unit
      val get : unit -> data
      val clear : unit -> unit
      val iter : (Computation.LIST_REF_OUTPUT.data_in_list -> unit) -> unit
      val fold_left :
        ('-> Computation.LIST_REF_OUTPUT.data_in_list -> 'a) -> '-> 'a
    end
  module ListRef :
    functor (Data : Project.Datatype.S->
      functor (Info : Signature.NAME_DPDS->
        sig
          type data_in_list = Data.t
          val self : Project.Computation.t
          val select :
            Kind.how ->
            Project.Computation.selection -> Project.Computation.selection
          val depend : Project.Computation.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 : Project.Datatype.S
          val howto_marshal :
            (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
          type data = Data.t list
          val set : data -> unit
          val get : unit -> data
          val clear : unit -> unit
          val iter : (data_in_list -> unit) -> unit
          val fold_left : ('-> data_in_list -> 'a) -> '-> 'a
        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 DASHTBL_OUTPUT =
    sig
      val self : Project.Computation.t
      val select :
        Kind.how ->
        Project.Computation.selection -> Project.Computation.selection
      val depend : Project.Computation.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 : Project.Datatype.S
      val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
      type key
      type data
      val add :
        Computation.DASHTBL_OUTPUT.key ->
        Project.Computation.t list -> Computation.DASHTBL_OUTPUT.data -> unit
      val replace :
        reset:bool ->
        Computation.DASHTBL_OUTPUT.key ->
        Project.Computation.t list -> Computation.DASHTBL_OUTPUT.data -> unit
      val memo :
        reset:bool ->
        (Computation.DASHTBL_OUTPUT.data list ->
         Computation.DASHTBL_OUTPUT.data) ->
        Computation.DASHTBL_OUTPUT.key ->
        Project.Computation.t list -> Computation.DASHTBL_OUTPUT.data
      val clear : reset:bool -> unit -> unit
      val remove :
        reset:bool ->
        Computation.DASHTBL_OUTPUT.key -> Project.Computation.t -> unit
      val remove_all : reset:bool -> Computation.DASHTBL_OUTPUT.key -> unit
      val filter :
        reset:bool ->
        (Computation.DASHTBL_OUTPUT.key ->
         Project.Computation.t -> Computation.DASHTBL_OUTPUT.data -> bool) ->
        Computation.DASHTBL_OUTPUT.key -> unit
      val mem : Computation.DASHTBL_OUTPUT.key -> bool
      val find :
        ?who:Project.Computation.t list ->
        Computation.DASHTBL_OUTPUT.key ->
        Project.Computation.t ->
        Computation.DASHTBL_OUTPUT.data * Project.Computation.t
      val find_data :
        ?who:Project.Computation.t list ->
        Computation.DASHTBL_OUTPUT.key ->
        Project.Computation.t -> Computation.DASHTBL_OUTPUT.data
      val find_state :
        ?who:Project.Computation.t list ->
        Computation.DASHTBL_OUTPUT.key ->
        Project.Computation.t -> Project.Computation.t
      val find_all_local :
        ?who:Project.Computation.t list ->
        Computation.DASHTBL_OUTPUT.key ->
        Project.Computation.t ->
        (Computation.DASHTBL_OUTPUT.data * Project.Computation.t) list
      val find_all_local_data :
        ?who:Project.Computation.t list ->
        Computation.DASHTBL_OUTPUT.key ->
        Project.Computation.t -> Computation.DASHTBL_OUTPUT.data list
      val find_all_local_state :
        ?who:Project.Computation.t list ->
        Computation.DASHTBL_OUTPUT.key ->
        Project.Computation.t -> Project.Computation.t list
      val find_all :
        ?who:Project.Computation.t list ->
        Computation.DASHTBL_OUTPUT.key ->
        (Computation.DASHTBL_OUTPUT.data * Project.Computation.t) list
      val find_all_data :
        ?who:Project.Computation.t list ->
        Computation.DASHTBL_OUTPUT.key ->
        Computation.DASHTBL_OUTPUT.data list
      val find_all_states :
        ?who:Project.Computation.t list ->
        Computation.DASHTBL_OUTPUT.key -> Project.Computation.t list
      val iter :
        (Computation.DASHTBL_OUTPUT.key ->
         Project.Computation.t -> Computation.DASHTBL_OUTPUT.data -> unit) ->
        unit
      val iter_key :
        (Project.Computation.t -> Computation.DASHTBL_OUTPUT.data -> unit) ->
        Computation.DASHTBL_OUTPUT.key -> unit
      val fold :
        (Computation.DASHTBL_OUTPUT.key ->
         Project.Computation.t -> Computation.DASHTBL_OUTPUT.data -> '-> 'a) ->
        '-> 'a
      val fold_key :
        (Project.Computation.t -> Computation.DASHTBL_OUTPUT.data -> '-> 'a) ->
        Computation.DASHTBL_OUTPUT.key -> '-> 'a
      val length : unit -> int
      val add_dependency :
        Project.Computation.t -> Project.Computation.t -> unit
    end
  module Make_Dashtbl :
    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 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 : Project.Datatype.S
            val howto_marshal :
              (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
            type key = H.key
            type data = Data.t
            val add : key -> Project.Computation.t list -> data -> unit
            val replace :
              reset:bool -> key -> Project.Computation.t list -> data -> unit
            val memo :
              reset:bool ->
              (data list -> data) ->
              key -> Project.Computation.t list -> data
            val clear : reset:bool -> unit -> unit
            val remove : reset:bool -> key -> Project.Computation.t -> unit
            val remove_all : reset:bool -> key -> unit
            val filter :
              reset:bool ->
              (key -> Project.Computation.t -> data -> bool) -> key -> unit
            val mem : key -> bool
            val find :
              ?who:Project.Computation.t list ->
              key -> Project.Computation.t -> data * Project.Computation.t
            val find_data :
              ?who:Project.Computation.t list ->
              key -> Project.Computation.t -> data
            val find_state :
              ?who:Project.Computation.t list ->
              key -> Project.Computation.t -> Project.Computation.t
            val find_all_local :
              ?who:Project.Computation.t list ->
              key ->
              Project.Computation.t -> (data * Project.Computation.t) list
            val find_all_local_data :
              ?who:Project.Computation.t list ->
              key -> Project.Computation.t -> data list
            val find_all_local_state :
              ?who:Project.Computation.t list ->
              key -> Project.Computation.t -> Project.Computation.t list
            val find_all :
              ?who:Project.Computation.t list ->
              key -> (data * Project.Computation.t) list
            val find_all_data :
              ?who:Project.Computation.t list -> key -> data list
            val find_all_states :
              ?who:Project.Computation.t list ->
              key -> Project.Computation.t list
            val iter : (key -> Project.Computation.t -> data -> unit) -> unit
            val iter_key :
              (Project.Computation.t -> data -> unit) -> key -> unit
            val fold :
              (key -> Project.Computation.t -> data -> '-> 'a) -> '-> 'a
            val fold_key :
              (Project.Computation.t -> data -> '-> 'a) -> key -> '-> 'a
            val length : unit -> int
            val add_dependency :
              Project.Computation.t -> Project.Computation.t -> unit
          end
  module Dashtbl :
    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 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 : Project.Datatype.S
            val howto_marshal :
              (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
            type key = Key.t
            type data = Data.t
            val add : key -> Project.Computation.t list -> data -> unit
            val replace :
              reset:bool -> key -> Project.Computation.t list -> data -> unit
            val memo :
              reset:bool ->
              (data list -> data) ->
              key -> Project.Computation.t list -> data
            val clear : reset:bool -> unit -> unit
            val remove : reset:bool -> key -> Project.Computation.t -> unit
            val remove_all : reset:bool -> key -> unit
            val filter :
              reset:bool ->
              (key -> Project.Computation.t -> data -> bool) -> key -> unit
            val mem : key -> bool
            val find :
              ?who:Project.Computation.t list ->
              key -> Project.Computation.t -> data * Project.Computation.t
            val find_data :
              ?who:Project.Computation.t list ->
              key -> Project.Computation.t -> data
            val find_state :
              ?who:Project.Computation.t list ->
              key -> Project.Computation.t -> Project.Computation.t
            val find_all_local :
              ?who:Project.Computation.t list ->
              key ->
              Project.Computation.t -> (data * Project.Computation.t) list
            val find_all_local_data :
              ?who:Project.Computation.t list ->
              key -> Project.Computation.t -> data list
            val find_all_local_state :
              ?who:Project.Computation.t list ->
              key -> Project.Computation.t -> Project.Computation.t list
            val find_all :
              ?who:Project.Computation.t list ->
              key -> (data * Project.Computation.t) list
            val find_all_data :
              ?who:Project.Computation.t list -> key -> data list
            val find_all_states :
              ?who:Project.Computation.t list ->
              key -> Project.Computation.t list
            val iter : (key -> Project.Computation.t -> data -> unit) -> unit
            val iter_key :
              (Project.Computation.t -> data -> unit) -> key -> unit
            val fold :
              (key -> Project.Computation.t -> data -> '-> 'a) -> '-> 'a
            val fold_key :
              (Project.Computation.t -> data -> '-> 'a) -> key -> '-> 'a
            val length : unit -> int
            val add_dependency :
              Project.Computation.t -> Project.Computation.t -> unit
          end
  module type WEAK_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 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 : Project.Datatype.S
      val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
      type data
      val merge :
        Computation.WEAK_HASHTBL_OUTPUT.data ->
        Computation.WEAK_HASHTBL_OUTPUT.data
      val add : Computation.WEAK_HASHTBL_OUTPUT.data -> unit
      val clear : unit -> unit
      val count : unit -> int
      val iter : (Computation.WEAK_HASHTBL_OUTPUT.data -> unit) -> unit
      val fold :
        (Computation.WEAK_HASHTBL_OUTPUT.data -> '-> 'a) -> '-> 'a
      val find :
        Computation.WEAK_HASHTBL_OUTPUT.data ->
        Computation.WEAK_HASHTBL_OUTPUT.data
      val find_all :
        Computation.WEAK_HASHTBL_OUTPUT.data ->
        Computation.WEAK_HASHTBL_OUTPUT.data list
      val mem : Computation.WEAK_HASHTBL_OUTPUT.data -> bool
      val remove : Computation.WEAK_HASHTBL_OUTPUT.data -> unit
    end
  module Make_WeakHashtbl :
    functor (W : Weak.S->
      functor
        (Data : sig
                  type t = W.data
                  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.project -> bool) -> t -> bool) option ref
                end->
        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 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 : Project.Datatype.S
            val howto_marshal :
              (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
            type data = W.data
            val merge : data -> data
            val add : data -> unit
            val clear : unit -> unit
            val count : unit -> int
            val iter : (data -> unit) -> unit
            val fold : (data -> '-> 'a) -> '-> 'a
            val find : data -> data
            val find_all : data -> data list
            val mem : data -> bool
            val remove : data -> unit
          end
  module WeakHashtbl :
    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 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 : Project.Datatype.S
          val howto_marshal :
            (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
          type data = Data.t
          val merge : data -> data
          val add : data -> unit
          val clear : unit -> unit
          val count : unit -> int
          val iter : (data -> unit) -> unit
          val fold : (data -> '-> 'a) -> '-> 'a
          val find : data -> data
          val find_all : data -> data list
          val mem : data -> bool
          val remove : data -> unit
        end
  module HashconsTbl :
    functor
      (Data : sig
                type t
                val name : string
                val equal_internal :
                  Computation.HashconsTbl.t ->
                  Computation.HashconsTbl.t -> bool
                val hash_internal : Computation.HashconsTbl.t -> int
                val initial_values : Computation.HashconsTbl.t list
              end->
      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 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 : Project.Datatype.S
          val howto_marshal :
            (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
          type data = Data.t
          val merge : data -> data
          val add : data -> unit
          val clear : unit -> unit
          val count : unit -> int
          val iter : (data -> unit) -> unit
          val fold : (data -> '-> 'a) -> '-> 'a
          val find : data -> data
          val find_all : data -> data list
          val mem : data -> bool
          val remove : data -> unit
        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 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 : Project.Datatype.S
      val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
      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 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 : Project.Datatype.S
            val howto_marshal :
              (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
            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 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 : Project.Datatype.S
            val howto_marshal :
              (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
            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 descr : Unmarshal.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 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 : Project.Datatype.S
      val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
      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 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.project -> bool) -> 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 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 : Project.Datatype.S
            val howto_marshal :
              (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
            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 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 : Project.Datatype.S
          val howto_marshal :
            (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
          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 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 : Project.Datatype.S
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        type data = Project.t
        val set : data -> unit
        val get : unit -> data
        val clear : unit -> unit
      end
end