functor (T : T.T3) ->
  functor (Tree : T.T3) ->
    functor (Key : T.T1) ->
      functor (Options : T.T3) ->
        functor
          (M : sig
                 val invariants :
                   ('k, 'cmp, ('k, 'v, 'cmp) T.t -> bool) Options.t
                 val is_empty : ('a, 'b, 'c) T.t -> bool
                 val length : ('a, 'b, 'c) T.t -> int
                 val add :
                   ('k, 'cmp,
                    ('k, 'v, 'cmp) T.t ->
                    key:'k Key.t -> data:'v -> ('k, 'v, 'cmp) T.t)
                   Options.t
                 val add_multi :
                   ('k, 'cmp,
                    ('k, 'v list, 'cmp) T.t ->
                    key:'k Key.t -> data:'v -> ('k, 'v list, 'cmp) T.t)
                   Options.t
                 val change :
                   ('k, 'cmp,
                    ('k, 'v, 'cmp) T.t ->
                    'k Key.t ->
                    ('v option -> 'v option) -> ('k, 'v, 'cmp) T.t)
                   Options.t
                 val find :
                   ('k, 'cmp, ('k, 'v, 'cmp) T.t -> 'k Key.t -> 'v option)
                   Options.t
                 val find_exn :
                   ('k, 'cmp, ('k, 'v, 'cmp) T.t -> 'k Key.t -> 'v) Options.t
                 val remove :
                   ('k, 'cmp,
                    ('k, 'v, 'cmp) T.t -> 'k Key.t -> ('k, 'v, 'cmp) T.t)
                   Options.t
                 val mem :
                   ('k, 'cmp, ('k, 'a, 'cmp) T.t -> 'k Key.t -> bool)
                   Options.t
                 val iter :
                   ('k, 'v, 'a) T.t ->
                   f:(key:'k Key.t -> data:'v -> unit) -> unit
                 val iter2 :
                   ('k, 'cmp,
                    ('k, 'v1, 'cmp) T.t ->
                    ('k, 'v2, 'cmp) T.t ->
                    f:(key:'k Key.t ->
                       data:[ `Both of 'v1 * 'v2
                            | `Left of 'v1
                            | `Right of 'v2 ] ->
                       unit) ->
                    unit)
                   Options.t
                 val map :
                   ('k, 'v1, 'cmp) T.t ->
                   f:('v1 -> 'v2) -> ('k, 'v2, 'cmp) T.t
                 val mapi :
                   ('k, 'v1, 'cmp) T.t ->
                   f:(key:'k Key.t -> data:'v1 -> 'v2) -> ('k, 'v2, 'cmp) T.t
                 val fold :
                   ('k, 'v, 'b) T.t ->
                   init:'a -> f:(key:'k Key.t -> data:'v -> 'a -> 'a) -> 'a
                 val fold_right :
                   ('k, 'v, 'b) T.t ->
                   init:'a -> f:(key:'k Key.t -> data:'v -> 'a -> 'a) -> 'a
                 val filter :
                   ('k, 'cmp,
                    ('k, 'v, 'cmp) T.t ->
                    f:(key:'k Key.t -> data:'v -> bool) -> ('k, 'v, 'cmp) T.t)
                   Options.t
                 val filter_map :
                   ('k, 'cmp,
                    ('k, 'v1, 'cmp) T.t ->
                    f:('v1 -> 'v2 option) -> ('k, 'v2, 'cmp) T.t)
                   Options.t
                 val filter_mapi :
                   ('k, 'cmp,
                    ('k, 'v1, 'cmp) T.t ->
                    f:(key:'k Key.t -> data:'v1 -> 'v2 option) ->
                    ('k, 'v2, 'cmp) T.t)
                   Options.t
                 val compare_direct :
                   ('k, 'cmp,
                    ('v -> 'v -> int) ->
                    ('k, 'v, 'cmp) T.t -> ('k, 'v, 'cmp) T.t -> int)
                   Options.t
                 val equal :
                   ('k, 'cmp,
                    ('v -> 'v -> bool) ->
                    ('k, 'v, 'cmp) T.t -> ('k, 'v, 'cmp) T.t -> bool)
                   Options.t
                 val keys : ('k, 'a, 'b) T.t -> 'k Key.t list
                 val data : ('a, 'v, 'b) T.t -> 'v list
                 val to_alist : ('k, 'v, 'a) T.t -> ('k Key.t * 'v) list
                 val validate :
                   name:('k Key.t -> string) ->
                   'v Validate.check -> ('k, 'v, 'a) T.t Validate.check
                 val merge :
                   ('k, 'cmp,
                    ('k, 'v1, 'cmp) T.t ->
                    ('k, 'v2, 'cmp) T.t ->
                    f:(key:'k Key.t ->
                       [ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] ->
                       'v3 option) ->
                    ('k, 'v3, 'cmp) T.t)
                   Options.t
                 val symmetric_diff :
                   ('k, 'cmp,
                    ('k, 'v, 'cmp) T.t ->
                    ('k, 'v, 'cmp) T.t ->
                    data_equal:('v -> 'v -> bool) ->
                    ('k Key.t *
                     [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ])
                    list)
                   Options.t
                 val min_elt : ('k, 'v, 'a) T.t -> ('k Key.t * 'v) option
                 val min_elt_exn : ('k, 'v, 'a) T.t -> 'k Key.t * 'v
                 val max_elt : ('k, 'v, 'a) T.t -> ('k Key.t * 'v) option
                 val max_elt_exn : ('k, 'v, 'a) T.t -> 'k Key.t * 'v
                 val for_all : ('k, 'v, 'a) T.t -> f:('v -> bool) -> bool
                 val exists : ('k, 'v, 'a) T.t -> f:('v -> bool) -> bool
                 val fold_range_inclusive :
                   ('k, 'cmp,
                    ('k, 'v, 'cmp) T.t ->
                    min:'k Key.t ->
                    max:'k Key.t ->
                    init:'a -> f:(key:'k Key.t -> data:'v -> 'a -> 'a) -> 'a)
                   Options.t
                 val range_to_alist :
                   ('k, 'cmp,
                    ('k, 'v, 'cmp) T.t ->
                    min:'k Key.t -> max:'k Key.t -> ('k Key.t * 'v) list)
                   Options.t
                 val prev_key :
                   ('k, 'cmp,
                    ('k, 'v, 'cmp) T.t -> 'k Key.t -> ('k Key.t * 'v) option)
                   Options.t
                 val next_key :
                   ('k, 'cmp,
                    ('k, 'v, 'cmp) T.t -> 'k Key.t -> ('k Key.t * 'v) option)
                   Options.t
                 val rank :
                   ('k, 'cmp, ('k, 'a, 'cmp) T.t -> 'k Key.t -> int option)
                   Options.t
                 val to_tree :
                   ('k, 'v, 'cmp) T.t -> ('k Key.t, 'v, 'cmp) Tree.t
               end) ->
          sig  end