sig
  type key = K.t
  type leaf_annot = bool
  type branch_annot = Hptmap.Tag_comp.t
  type tt = private
      Empty
    | Leaf of key * V.t * bool
    | Branch of int * int * tt * 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 : key -> V.t -> t -> t
  val find : key -> t -> V.t
  val remove : key -> t -> t
  val mem : key -> t -> bool
  val iter : (K.t -> V.t -> unit) -> t -> unit
  val map : (V.t -> V.t) -> t -> t
  val fold : (K.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 * subtree * subtree
  val find_prefix : t -> Hptmap.prefix -> subtree option
  val hash_subtree : subtree -> int
  val equal_subtree : subtree -> subtree -> bool
  val generic_merge :
    cache:string * int ->
    decide:(K.t -> V.t option -> V.t option -> V.t) -> t -> t -> t
  val symetric_merge :
    cache:string * int ->
    decide_none:(K.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:(K.t -> V.t -> unit) ->
    decide_snd:(K.t -> V.t -> unit) ->
    decide_both:(V.t -> V.t -> unit) -> t -> t -> unit
  val cached_fold :
    cache:string * int ->
    temporary:bool ->
    f:(key -> V.t -> 'a) -> joiner:('-> '-> 'a) -> empty:'-> t -> 'a
  val cached_map :
    cache:string * int -> temporary:bool -> f:(key -> V.t -> V.t) -> t -> t
  val is_singleton : t -> (key * V.t) option
  val min_binding : t -> key * V.t
end