functor (Key : Id_Datatype->
  functor (V : Datatype.S->
    functor
      (Compositional_bool : sig
                              val e : bool
                              val f : Key.t -> V.t -> bool
                              val compose : bool -> bool -> bool
                              val default : bool
                            end->
      functor (Initial_Values : sig val v : (Key.t * V.t) list list end->
        functor (Datatype_deps : sig val l : State.t list end->
          sig
            type key = Key.t
            type t
            val ty : t Type.t
            val name : string
            val descr : t Descr.t
            val packed_descr : Structural_descr.pack
            val reprs : t list
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val pretty_code : Format.formatter -> t -> unit
            val internal_pretty_code :
              Type.precedence -> Format.formatter -> t -> unit
            val pretty : Format.formatter -> t -> unit
            val varname : t -> string
            val mem_project : (Project_skeleton.t -> bool) -> t -> bool
            val copy : t -> t
            module Set :
              sig
                type elt = t
                type t
                val empty : t
                val is_empty : t -> bool
                val mem : elt -> t -> bool
                val add : elt -> t -> t
                val singleton : elt -> t
                val remove : elt -> t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val subset : t -> t -> bool
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> '-> 'a) -> t -> '-> 'a
                val for_all : (elt -> bool) -> t -> bool
                val exists : (elt -> bool) -> t -> bool
                val filter : (elt -> bool) -> t -> t
                val partition : (elt -> bool) -> t -> t * t
                val cardinal : t -> int
                val elements : t -> elt list
                val choose : t -> elt
                val split : elt -> t -> t * bool * t
                val find : elt -> t -> elt
                val of_list : elt list -> t
                val min_elt : t -> elt
                val max_elt : t -> elt
                val nearest_elt_le : elt -> t -> elt
                val nearest_elt_ge : elt -> t -> elt
                val ty : t Type.t
                val name : string
                val descr : t Descr.t
                val packed_descr : Structural_descr.pack
                val reprs : t list
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val hash : t -> int
                val pretty_code : Format.formatter -> t -> unit
                val internal_pretty_code :
                  Type.precedence -> Format.formatter -> t -> unit
                val pretty : Format.formatter -> t -> unit
                val varname : t -> string
                val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                val copy : t -> t
              end
            module Map :
              sig
                type key = t
                type +'a t
                val empty : 'a t
                val is_empty : 'a t -> bool
                val mem : key -> 'a t -> bool
                val add : key -> '-> 'a t -> 'a t
                val singleton : key -> '-> 'a t
                val remove : key -> 'a t -> 'a t
                val merge :
                  (key -> 'a option -> 'b option -> 'c option) ->
                  'a t -> 'b t -> 'c t
                val compare : ('-> '-> int) -> 'a t -> 'a t -> int
                val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val for_all : (key -> '-> bool) -> 'a t -> bool
                val exists : (key -> '-> bool) -> 'a t -> bool
                val filter : (key -> '-> bool) -> 'a t -> 'a t
                val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
                val cardinal : 'a t -> int
                val bindings : 'a t -> (key * 'a) list
                val min_binding : 'a t -> key * 'a
                val max_binding : 'a t -> key * 'a
                val choose : 'a t -> key * 'a
                val split : key -> 'a t -> 'a t * 'a option * 'a t
                val find : key -> 'a t -> 'a
                val map : ('-> 'b) -> 'a t -> 'b t
                val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                module Key :
                  sig
                    type t = key
                    val ty : t Type.t
                    val name : string
                    val descr : t Descr.t
                    val packed_descr : Structural_descr.pack
                    val reprs : t list
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    val hash : t -> int
                    val pretty_code : Format.formatter -> t -> unit
                    val internal_pretty_code :
                      Type.precedence -> Format.formatter -> t -> unit
                    val pretty : Format.formatter -> t -> unit
                    val varname : t -> string
                    val mem_project :
                      (Project_skeleton.t -> bool) -> t -> bool
                    val copy : t -> t
                  end
                module Make :
                  functor (Data : Datatype.S->
                    sig
                      type t = Data.t t
                      val ty : t Type.t
                      val name : string
                      val descr : t Descr.t
                      val packed_descr : Structural_descr.pack
                      val reprs : t list
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val hash : t -> int
                      val pretty_code : Format.formatter -> t -> unit
                      val internal_pretty_code :
                        Type.precedence -> Format.formatter -> t -> unit
                      val pretty : Format.formatter -> t -> unit
                      val varname : t -> string
                      val mem_project :
                        (Project_skeleton.t -> bool) -> t -> bool
                      val copy : t -> t
                    end
              end
            module Hashtbl :
              sig
                type key = t
                type 'a t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val reset : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> '-> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val length : 'a t -> int
                val stats : 'a t -> Hashtbl.statistics
                val iter_sorted :
                  ?cmp:(key -> key -> int) ->
                  (key -> '-> unit) -> 'a t -> unit
                val fold_sorted :
                  ?cmp:(key -> key -> int) ->
                  (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val iter_sorted_by_entry :
                  cmp:(key * '-> key * '-> int) ->
                  (key -> '-> unit) -> 'a t -> unit
                val fold_sorted_by_entry :
                  cmp:(key * '-> key * '-> int) ->
                  (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val iter_sorted_by_value :
                  cmp:('-> '-> int) ->
                  (key -> '-> unit) -> 'a t -> unit
                val fold_sorted_by_value :
                  cmp:('-> '-> int) ->
                  (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val structural_descr :
                  Structural_descr.t -> Structural_descr.t
                val make_type : 'Type.t -> 'a t Type.t
                val memo : 'a t -> key -> (key -> 'a) -> 'a
                module Key :
                  sig
                    type t = key
                    val ty : t Type.t
                    val name : string
                    val descr : t Descr.t
                    val packed_descr : Structural_descr.pack
                    val reprs : t list
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    val hash : t -> int
                    val pretty_code : Format.formatter -> t -> unit
                    val internal_pretty_code :
                      Type.precedence -> Format.formatter -> t -> unit
                    val pretty : Format.formatter -> t -> unit
                    val varname : t -> string
                    val mem_project :
                      (Project_skeleton.t -> bool) -> t -> bool
                    val copy : t -> t
                  end
                module Make :
                  functor (Data : Datatype.S->
                    sig
                      type t = Data.t t
                      val ty : t Type.t
                      val name : string
                      val descr : t Descr.t
                      val packed_descr : Structural_descr.pack
                      val reprs : t list
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val hash : t -> int
                      val pretty_code : Format.formatter -> t -> unit
                      val internal_pretty_code :
                        Type.precedence -> Format.formatter -> t -> unit
                      val pretty : Format.formatter -> t -> unit
                      val varname : t -> string
                      val mem_project :
                        (Project_skeleton.t -> bool) -> t -> bool
                      val copy : t -> t
                    end
              end
            val self : State.t
            val empty : Hptmap.Make.t
            val hash : Hptmap.Make.t -> int
            val is_empty : Hptmap.Make.t -> bool
            val add :
              Hptmap.Make.key -> V.t -> Hptmap.Make.t -> Hptmap.Make.t
            val find : Hptmap.Make.key -> Hptmap.Make.t -> V.t
            val find_key :
              Hptmap.Make.key -> Hptmap.Make.t -> Hptmap.Make.key
            val remove : Hptmap.Make.key -> Hptmap.Make.t -> Hptmap.Make.t
            val mem : Hptmap.Make.key -> Hptmap.Make.t -> bool
            val iter : (Key.t -> V.t -> unit) -> Hptmap.Make.t -> unit
            val map : (V.t -> V.t) -> Hptmap.Make.t -> Hptmap.Make.t
            val map' :
              (Key.t -> V.t -> V.t option) -> Hptmap.Make.t -> Hptmap.Make.t
            val fold :
              (Key.t -> V.t -> '-> 'b) -> Hptmap.Make.t -> '-> 'b
            val fold_rev :
              (Key.t -> V.t -> '-> 'b) -> Hptmap.Make.t -> '-> 'b
            val for_all : (Key.t -> V.t -> bool) -> Hptmap.Make.t -> bool
            val exists : (Key.t -> V.t -> bool) -> Hptmap.Make.t -> bool
            val generic_merge :
              cache:string * bool ->
              decide:(Key.t -> V.t option -> V.t option -> V.t) ->
              idempotent:bool ->
              Hptmap.Make.t -> Hptmap.Make.t -> Hptmap.Make.t
            val symmetric_merge :
              cache:string * '->
              decide_none:(Key.t -> V.t -> V.t) ->
              decide_some:(V.t -> V.t -> V.t) ->
              Hptmap.Make.t -> Hptmap.Make.t -> Hptmap.Make.t
            val symmetric_inter :
              cache:string * '->
              decide_some:(Key.t -> V.t -> V.t -> V.t option) ->
              Hptmap.Make.t -> Hptmap.Make.t -> Hptmap.Make.t
            val inter_with_shape :
              'Shape(Key).t -> Hptmap.Make.t -> Hptmap.Make.t
            type decide_fast = Done | Unknown
            val generic_predicate :
              exn ->
              cache:string * '->
              decide_fast:(Hptmap.Make.t ->
                           Hptmap.Make.t -> Hptmap.Make.decide_fast) ->
              decide_fst:(Key.t -> V.t -> unit) ->
              decide_snd:(Key.t -> V.t -> unit) ->
              decide_both:(V.t -> V.t -> unit) ->
              Hptmap.Make.t -> Hptmap.Make.t -> unit
            type predicate_type = ExistentialPredicate | UniversalPredicate
            type predicate_result = PTrue | PFalse | PUnknown
            type cache_type =
                NoCache
              | PersistentCache of string
              | TemporaryCache of string
            val binary_predicate :
              Hptmap.Make.cache_type ->
              Hptmap.Make.predicate_type ->
              decide_fast:(Hptmap.Make.t ->
                           Hptmap.Make.t -> Hptmap.Make.predicate_result) ->
              decide_fst:(Key.t -> V.t -> bool) ->
              decide_snd:(Key.t -> V.t -> bool) ->
              decide_both:(Key.t -> V.t -> V.t -> bool) ->
              Hptmap.Make.t -> Hptmap.Make.t -> bool
            val generic_symmetric_predicate :
              exn ->
              decide_fast:(Hptmap.Make.t ->
                           Hptmap.Make.t -> Hptmap.Make.decide_fast) ->
              decide_one:(Key.t -> V.t -> unit) ->
              decide_both:(V.t -> V.t -> unit) ->
              Hptmap.Make.t -> Hptmap.Make.t -> unit
            val symmetric_binary_predicate :
              Hptmap.Make.cache_type ->
              Hptmap.Make.predicate_type ->
              decide_fast:(Hptmap.Make.t ->
                           Hptmap.Make.t -> Hptmap.Make.predicate_result) ->
              decide_one:(Key.t -> V.t -> bool) ->
              decide_both:(Key.t -> V.t -> V.t -> bool) ->
              Hptmap.Make.t -> Hptmap.Make.t -> bool
            val decide_fast_inclusion :
              Hptmap.Make.t -> Hptmap.Make.t -> Hptmap.Make.predicate_result
            val decide_fast_intersection :
              Hptmap.Make.t -> Hptmap.Make.t -> Hptmap.Make.predicate_result
            val cached_fold :
              cache_name:string ->
              temporary:bool ->
              f:(Hptmap.Make.key -> V.t -> 'b) ->
              joiner:('-> '-> 'b) -> empty:'-> Hptmap.Make.t -> 'b
            val cached_map :
              cache:string * int ->
              temporary:bool ->
              f:(Hptmap.Make.key -> V.t -> V.t) ->
              Hptmap.Make.t -> Hptmap.Make.t
            val singleton : Hptmap.Make.key -> V.t -> Hptmap.Make.t
            val is_singleton :
              Hptmap.Make.t -> (Hptmap.Make.key * V.t) option
            val cardinal : Hptmap.Make.t -> int
            val min_binding : Hptmap.Make.t -> Hptmap.Make.key * V.t
            val max_binding : Hptmap.Make.t -> Hptmap.Make.key * V.t
            val split :
              Hptmap.Make.key ->
              Hptmap.Make.t -> Hptmap.Make.t * V.t option * Hptmap.Make.t
            val compositional_bool : Hptmap.Make.t -> bool
            val clear_caches : unit -> unit
            val from_shape :
              (Key.t -> '-> V.t) -> 'Shape(Key).t -> Hptmap.Make.t
            val shape : Hptmap.Make.t -> V.t Shape(Key).t
            val hash_debug : Hptmap.Make.t -> int
            val pretty_debug : Format.formatter -> Hptmap.Make.t -> unit
            val comp_prefixes : Hptmap.Make.t -> Hptmap.Make.t -> unit
            val pretty_prefix :
              Hptmap.prefix -> Format.formatter -> Hptmap.Make.t -> unit
            type subtree
            exception Found_prefix of Hptmap.prefix * Hptmap.Make.subtree *
                        Hptmap.Make.subtree
            val find_prefix :
              Hptmap.Make.t -> Hptmap.prefix -> Hptmap.Make.subtree option
            val hash_subtree : Hptmap.Make.subtree -> int
            val equal_subtree :
              Hptmap.Make.subtree -> Hptmap.Make.subtree -> bool
          end