# Module type Core_map_intf.Accessors_generic

    module type Accessors_generic = sig .. end

    type ('a, 'b, 'cmp) t

    type ('a, 'b, 'cmp) tree

    type 'a key

    type ('a, 'cmp, 'z) options

    val invariants : ('k, 'cmp, ('k, 'v, 'cmp) t -> bool)
           options

    val is_empty : ('a, 'b, 'c) t -> bool

    val length : ('a, 'b, 'c) t -> int

    val add : ('k, 'cmp,
            ('k, 'v, 'cmp) t ->
            key:'k key ->
            data:'v -> ('k, 'v, 'cmp) t)
           options

    val add_multi : ('k, 'cmp,
            ('k, 'v list, 'cmp) t ->
            key:'k key ->
            data:'v -> ('k, 'v list, 'cmp) t)
           options

    val change : ('k, 'cmp,
            ('k, 'v, 'cmp) t ->
            'k key ->
            ('v option -> 'v option) -> ('k, 'v, 'cmp) t)
           options

    val find : ('k, 'cmp,
            ('k, 'v, 'cmp) t ->
            'k key -> 'v option)
           options

    val find_exn : ('k, 'cmp,
            ('k, 'v, 'cmp) t ->
            'k key -> 'v)
           options

    val remove : ('k, 'cmp,
            ('k, 'v, 'cmp) t ->
            'k key ->
            ('k, 'v, 'cmp) t)
           options

    val mem : ('k, 'cmp,
            ('k, 'a, 'cmp) t ->
            'k key -> bool)
           options

    val iter : ('k, 'v, 'a) t ->
           f:(key:'k key -> data:'v -> unit) -> unit

    val iter2 : ('k, 'cmp,
            ('k, 'v1, 'cmp) t ->
            ('k, 'v2, 'cmp) t ->
            f:(key:'k key ->
               data:[ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] -> unit) ->
            unit)
           options

    val map : ('k, 'v1, 'cmp) t ->
           f:('v1 -> 'v2) -> ('k, 'v2, 'cmp) t

    val mapi : ('k, 'v1, 'cmp) t ->
           f:(key:'k key -> data:'v1 -> 'v2) ->
           ('k, 'v2, 'cmp) t

    val fold : ('k, 'v, 'b) t ->
           init:'a ->
           f:(key:'k key -> data:'v -> 'a -> 'a) -> 'a

    val fold_right : ('k, 'v, 'b) t ->
           init:'a ->
           f:(key:'k key -> data:'v -> 'a -> 'a) -> 'a

    val filter : ('k, 'cmp,
            ('k, 'v, 'cmp) t ->
            f:(key:'k key -> data:'v -> bool) ->
            ('k, 'v, 'cmp) t)
           options

    val filter_map : ('k, 'cmp,
            ('k, 'v1, 'cmp) t ->
            f:('v1 -> 'v2 option) -> ('k, 'v2, 'cmp) t)
           options

    val filter_mapi : ('k, 'cmp,
            ('k, 'v1, 'cmp) t ->
            f:(key:'k key -> data:'v1 -> 'v2 option) ->
            ('k, 'v2, 'cmp) t)
           options

    val compare_direct : ('k, 'cmp,
            ('v -> 'v -> int) ->
            ('k, 'v, 'cmp) t ->
            ('k, 'v, 'cmp) t -> int)
           options

    val equal : ('k, 'cmp,
            ('v -> 'v -> bool) ->
            ('k, 'v, 'cmp) t ->
            ('k, 'v, 'cmp) t -> bool)
           options

    val keys : ('k, 'a, 'b) t ->
           'k key list

    val data : ('a, 'v, 'b) t -> 'v list

    val to_alist : ('k, 'v, 'a) t ->
           ('k key * 'v) list

    val validate : name:('k key -> string) ->
           'v Validate.check ->
           ('k, 'v, 'a) t Validate.check

    val merge : ('k, 'cmp,
            ('k, 'v1, 'cmp) t ->
            ('k, 'v2, 'cmp) t ->
            f:(key:'k key ->
               [ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] -> 'v3 option) ->
            ('k, 'v3, 'cmp) t)
           options

    val symmetric_diff : ('k, 'cmp,
            ('k, 'v, 'cmp) t ->
            ('k, 'v, 'cmp) t ->
            data_equal:('v -> 'v -> bool) ->
            ('k key *
             [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ])
            Sequence.t)
           options

    val min_elt : ('k, 'v, 'a) t ->
           ('k key * 'v) option

    val min_elt_exn : ('k, 'v, 'a) t ->
           'k key * 'v

    val max_elt : ('k, 'v, 'a) t ->
           ('k key * 'v) option

    val max_elt_exn : ('k, 'v, 'a) t ->
           'k key * 'v

    val for_all : ('k, 'v, 'a) t -> f:('v -> bool) -> bool

    val exists : ('k, 'v, 'a) t -> f:('v -> bool) -> bool

    val split : ('k, 'cmp,
            ('k, 'v, 'cmp) t ->
            'k key ->
            ('k, 'v, 'cmp) t *
            ('k key * 'v) option *
            ('k, 'v, 'cmp) t)
           options

    val fold_range_inclusive : ('k, 'cmp,
            ('k, 'v, 'cmp) t ->
            min:'k key ->
            max:'k key ->
            init:'a ->
            f:(key:'k key -> data:'v -> 'a -> 'a) -> 'a)
           options

    val range_to_alist : ('k, 'cmp,
            ('k, 'v, 'cmp) t ->
            min:'k key ->
            max:'k key ->
            ('k key * 'v) list)
           options

    val closest_key : ('k, 'cmp,
            ('k, 'v, 'cmp) t ->
            [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ] ->
            'k key ->
            ('k key * 'v) option)
           options

    val nth : ('k, 'cmp,
            ('k, 'v, 'cmp) t ->
            int -> ('k key * 'v) option)
           options

    val rank : ('k, 'cmp,
            ('k, 'a, 'cmp) t ->
            'k key -> int option)
           options

    val to_tree : ('k, 'v, 'cmp) t ->
           ('k key, 'v, 'cmp)
           tree

    val to_sequence : ('k, 'cmp,
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:'k key ->
            ?keys_less_or_equal_to:'k key ->
            ('k, 'v, 'cmp) t ->
            ('k key * 'v) Sequence.t)
           options