functor
  (T : T.T3) (Tree : T.T3) (Key : T.T1) (Options : T.T3) (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:
                                                                   'Key.t ->
                                                                   data:'->
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t)
                                                                  Options.t
                                                                val add_multi :
                                                                  ('k, 'cmp,
                                                                   ('k,
                                                                    'v list,
                                                                    'cmp)
                                                                   T.t ->
                                                                   key:
                                                                   'Key.t ->
                                                                   data:'->
                                                                   ('k,
                                                                    'v list,
                                                                    'cmp)
                                                                   T.t)
                                                                  Options.t
                                                                val change :
                                                                  ('k, 'cmp,
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t ->
                                                                   'Key.t ->
                                                                   ('v option ->
                                                                    'v option) ->
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t)
                                                                  Options.t
                                                                val find :
                                                                  ('k, 'cmp,
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t ->
                                                                   'Key.t ->
                                                                   'v option)
                                                                  Options.t
                                                                val find_exn :
                                                                  ('k, 'cmp,
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t ->
                                                                   'Key.t ->
                                                                   'v)
                                                                  Options.t
                                                                val remove :
                                                                  ('k, 'cmp,
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t ->
                                                                   'Key.t ->
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t)
                                                                  Options.t
                                                                val mem :
                                                                  ('k, 'cmp,
                                                                   ('k, 'a,
                                                                    'cmp)
                                                                   T.t ->
                                                                   'Key.t ->
                                                                   bool)
                                                                  Options.t
                                                                val iter :
                                                                  ('k, 'v,
                                                                   'a)
                                                                  T.t ->
                                                                  f:(key:
                                                                    'Key.t ->
                                                                    data:'->
                                                                    unit) ->
                                                                  unit
                                                                val iter2 :
                                                                  ('k, 'cmp,
                                                                   ('k, 'v1,
                                                                    'cmp)
                                                                   T.t ->
                                                                   ('k, 'v2,
                                                                    'cmp)
                                                                   T.t ->
                                                                   f:
                                                                   (key:
                                                                    '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:
                                                                    'Key.t ->
                                                                    data:'v1 ->
                                                                    'v2) ->
                                                                  ('k, 'v2,
                                                                   'cmp)
                                                                  T.t
                                                                val fold :
                                                                  ('k, 'v,
                                                                   'b)
                                                                  T.t ->
                                                                  init:'->
                                                                  f:(key:
                                                                    'Key.t ->
                                                                    data:'->
                                                                    '-> 'a) ->
                                                                  'a
                                                                val fold_right :
                                                                  ('k, 'v,
                                                                   'b)
                                                                  T.t ->
                                                                  init:'->
                                                                  f:(key:
                                                                    'Key.t ->
                                                                    data:'->
                                                                    '-> 'a) ->
                                                                  'a
                                                                val filter :
                                                                  ('k, 'cmp,
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t ->
                                                                   f:
                                                                   (key:
                                                                    'Key.t ->
                                                                    data:'->
                                                                    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:
                                                                    'Key.t ->
                                                                    data:'v1 ->
                                                                    'v2
                                                                    option) ->
                                                                   ('k, 'v2,
                                                                    'cmp)
                                                                   T.t)
                                                                  Options.t
                                                                val compare_direct :
                                                                  ('k, 'cmp,
                                                                   ('->
                                                                    '-> int) ->
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t ->
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t -> 
                                                                   int)
                                                                  Options.t
                                                                val equal :
                                                                  ('k, 'cmp,
                                                                   ('->
                                                                    '->
                                                                    bool) ->
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t ->
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t ->
                                                                   bool)
                                                                  Options.t
                                                                val keys :
                                                                  ('k, 'a,
                                                                   'b)
                                                                  T.t ->
                                                                  'Key.t
                                                                  list
                                                                val data :
                                                                  ('a, 'v,
                                                                   'b)
                                                                  T.t ->
                                                                  'v list
                                                                val to_alist :
                                                                  ('k, 'v,
                                                                   'a)
                                                                  T.t ->
                                                                  ('Key.t *
                                                                   'v)
                                                                  list
                                                                val validate :
                                                                  name:
                                                                  ('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:
                                                                    '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:
                                                                   ('->
                                                                    '->
                                                                    bool) ->
                                                                   ('Key.t *
                                                                    [ 
                                                                    `Left of
                                                                    'v
                                                                  | `Right of
                                                                    'v
                                                                  | `Unequal of
                                                                    'v * 'v ])
                                                                   Sequence.t)
                                                                  Options.t
                                                                val min_elt :
                                                                  ('k, 'v,
                                                                   'a)
                                                                  T.t ->
                                                                  ('Key.t *
                                                                   'v)
                                                                  option
                                                                val min_elt_exn :
                                                                  ('k, 'v,
                                                                   'a)
                                                                  T.t ->
                                                                  'Key.t *
                                                                  'v
                                                                val max_elt :
                                                                  ('k, 'v,
                                                                   'a)
                                                                  T.t ->
                                                                  ('Key.t *
                                                                   'v)
                                                                  option
                                                                val max_elt_exn :
                                                                  ('k, 'v,
                                                                   'a)
                                                                  T.t ->
                                                                  'Key.t *
                                                                  'v
                                                                val for_all :
                                                                  ('k, 'v,
                                                                   'a)
                                                                  T.t ->
                                                                  f:('->
                                                                    bool) ->
                                                                  bool
                                                                val exists :
                                                                  ('k, 'v,
                                                                   'a)
                                                                  T.t ->
                                                                  f:('->
                                                                    bool) ->
                                                                  bool
                                                                val split :
                                                                  ('k, 'cmp,
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t ->
                                                                   'Key.t ->
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t *
                                                                   ('Key.t *
                                                                    'v)
                                                                   option *
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t)
                                                                  Options.t
                                                                val fold_range_inclusive :
                                                                  ('k, 'cmp,
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t ->
                                                                   min:
                                                                   'Key.t ->
                                                                   max:
                                                                   'Key.t ->
                                                                   init:'->
                                                                   f:
                                                                   (key:
                                                                    'Key.t ->
                                                                    data:'->
                                                                    '-> 'a) ->
                                                                   'a)
                                                                  Options.t
                                                                val range_to_alist :
                                                                  ('k, 'cmp,
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t ->
                                                                   min:
                                                                   'Key.t ->
                                                                   max:
                                                                   'Key.t ->
                                                                   ('Key.t *
                                                                    'v)
                                                                   list)
                                                                  Options.t
                                                                val closest_key :
                                                                  ('k, 'cmp,
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t ->
                                                                   [ 
                                                                   `Greater_or_equal_to
                                                                 | `Greater_than
                                                                 | `Less_or_equal_to
                                                                 | `Less_than ] ->
                                                                   'Key.t ->
                                                                   ('Key.t *
                                                                    'v)
                                                                   option)
                                                                  Options.t
                                                                val nth :
                                                                  ('k, 'cmp,
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t ->
                                                                   int ->
                                                                   ('Key.t *
                                                                    'v)
                                                                   option)
                                                                  Options.t
                                                                val rank :
                                                                  ('k, 'cmp,
                                                                   ('k, 'a,
                                                                    'cmp)
                                                                   T.t ->
                                                                   'Key.t ->
                                                                   int option)
                                                                  Options.t
                                                                val to_tree :
                                                                  ('k, 'v,
                                                                   'cmp)
                                                                  T.t ->
                                                                  ('Key.t,
                                                                   'v, 'cmp)
                                                                  Tree.t
                                                                val to_sequence :
                                                                  ('k, 'cmp,
                                                                   ?order:[ 
                                                                   `Decreasing_key
                                                                 | `Increasing_key ] ->
                                                                   ?keys_greater_or_equal_to:
                                                                   'Key.t ->
                                                                   ?keys_less_or_equal_to:
                                                                   'Key.t ->
                                                                   ('k, 'v,
                                                                    'cmp)
                                                                   T.t ->
                                                                   ('Key.t *
                                                                    'v)
                                                                   Sequence.t)
                                                                  Options.t
                                                              end->
  sig  end