sig
  type (_, _) eq = Eq : ('a, 'a) Structure.eq
  module type Key =
    sig
      type 'a key
      val create_key : string -> 'Structure.Key.key
      val eq_type :
        'Structure.Key.key ->
        'Structure.Key.key -> ('a, 'b) Structure.eq option
      val print : 'Structure.Key.key Pretty_utils.formatter
      val compare : 'Structure.Key.key -> 'Structure.Key.key -> int
      val equal : 'Structure.Key.key -> 'Structure.Key.key -> bool
      val hash : 'Structure.Key.key -> int
      val tag : 'Structure.Key.key -> int
    end
  module Make : functor () -> Key
  module Key_Value : Key
  module Key_Location : Key
  module Key_Domain : Key
  module type Shape =
    sig
      type 'a key
      val create_key : string -> 'a key
      val eq_type : 'a key -> 'b key -> ('a, 'b) eq option
      val print : 'a key Pretty_utils.formatter
      val compare : 'a key -> 'b key -> int
      val equal : 'a key -> 'b key -> bool
      val hash : 'a key -> int
      val tag : 'a key -> int
      type 'a data
      type 'a structure =
          Unit : unit Structure.Shape.structure
        | Void : 'Structure.Shape.structure
        | Leaf : 'a key *
            'Structure.Shape.data -> 'Structure.Shape.structure
        | Node : 'Structure.Shape.structure *
            'Structure.Shape.structure -> ('a * 'b)
                                            Structure.Shape.structure
        | Option : 'Structure.Shape.structure *
            '-> 'a option Structure.Shape.structure
      val eq_structure :
        'Structure.Shape.structure ->
        'Structure.Shape.structure -> ('a, 'b) Structure.eq option
    end
  module Shape :
    functor (Key : Key) (Data : sig type 'a t end->
      sig
        type 'a key = 'Key.key
        val create_key : string -> 'a key
        val eq_type : 'a key -> 'b key -> ('a, 'b) eq option
        val print : 'a key Pretty_utils.formatter
        val compare : 'a key -> 'b key -> int
        val equal : 'a key -> 'b key -> bool
        val hash : 'a key -> int
        val tag : 'a key -> int
        type 'a data = 'Data.t
        type 'a structure =
            Unit : unit structure
          | Void : 'a structure
          | Leaf : 'a key * 'a data -> 'a structure
          | Node : 'a structure * 'b structure -> ('a * 'b) structure
          | Option : 'a structure * '-> 'a option structure
        val eq_structure : 'a structure -> 'b structure -> ('a, 'b) eq option
      end
  module type Internal =
    sig
      type t
      type 'a structure
      val structure : Structure.Internal.t Structure.Internal.structure
    end
  module type External =
    sig
      type t
      type 'a key
      val mem : 'Structure.External.key -> bool
      val get :
        'Structure.External.key -> (Structure.External.t -> 'a) option
      val set :
        'Structure.External.key ->
        '-> Structure.External.t -> Structure.External.t
    end
  module Open :
    functor (Shape : Shape)
      (Data : sig type t val structure : t Shape.structure end->
      sig
        val mem : 'Shape.key -> bool
        val get : 'Shape.key -> (Data.t -> 'a) option
        val set : 'Shape.key -> '-> Data.t -> Data.t
      end
end