functor
  (Key : sig
           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 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
           val id : t -> int
         end->
  functor (V : Tagged_type->
    functor
      (Comp : 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->
        sig
          type key = Key.t
          type leaf_annot = bool
          type branch_annot = Hptmap.Tag_comp.t
          type tt = private
              Empty
            | Leaf of Hptmap.Make.key * V.t * bool
            | Branch of int * int * Hptmap.Make.tt * Hptmap.Make.tt *
                Hptmap.Tag_comp.t
          type t = tt
          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
          val empty : t
          val tag : t -> int
          val hash_debug : t -> int
          val is_empty : t -> bool
          val comp : t -> bool
          val add : Hptmap.Make.key -> V.t -> t -> t
          val find : Hptmap.Make.key -> t -> V.t
          val remove : Hptmap.Make.key -> t -> t
          val mem : Hptmap.Make.key -> t -> bool
          val iter : (Key.t -> V.t -> unit) -> t -> unit
          val map : (V.t -> V.t) -> t -> t
          val fold : (Key.t -> V.t -> '-> 'a) -> t -> '-> 'a
          val comp_prefixes : t -> t -> unit
          val pretty_prefix : Hptmap.prefix -> Format.formatter -> t -> unit
          type subtree
          exception Found_prefix of Hptmap.prefix * Hptmap.Make.subtree *
                      Hptmap.Make.subtree
          val find_prefix : t -> Hptmap.prefix -> Hptmap.Make.subtree option
          val hash_subtree : Hptmap.Make.subtree -> int
          val equal_subtree :
            Hptmap.Make.subtree -> Hptmap.Make.subtree -> bool
          val generic_merge :
            cache:string * int ->
            decide:(Key.t -> V.t option -> V.t option -> V.t) -> t -> t -> t
          val symetric_merge :
            cache:string * int ->
            decide_none:(Key.t -> V.t -> V.t) ->
            decide_some:(V.t -> V.t -> V.t) -> t -> t -> t
          val generic_is_included :
            exn ->
            cache:string * int ->
            decide_fst:(Key.t -> V.t -> unit) ->
            decide_snd:(Key.t -> V.t -> unit) ->
            decide_both:(V.t -> V.t -> unit) -> t -> t -> unit
          val cached_fold :
            cache:string * int ->
            temporary:bool ->
            f:(Hptmap.Make.key -> V.t -> 'a) ->
            joiner:('-> '-> 'a) -> empty:'-> t -> 'a
          val cached_map :
            cache:string * int ->
            temporary:bool -> f:(Hptmap.Make.key -> V.t -> V.t) -> t -> t
          val is_singleton : t -> (Hptmap.Make.key * V.t) option
          val min_binding : t -> Hptmap.Make.key * V.t
        end