# Module type Core_map_intf.Accessors1

    module type Accessors1 = sig .. end

    type 'a t

    type 'a tree

    type key

    val invariants : 'a t -> bool

    val is_empty : 'a t -> bool

    val length : 'a t -> int

    val add : 'a t ->
           key:key -> data:'a -> 'a t

    val add_multi : 'a list t ->
           key:key ->
           data:'a -> 'a list t

    val change : 'a t ->
           key ->
           ('a option -> 'a option) -> 'a t

    val find : 'a t -> key -> 'a option

    val find_exn : 'a t -> key -> 'a

    val remove : 'a t ->
           key -> 'a t

    val mem : 'a t -> key -> bool

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

    val iter2 : 'a t ->
           'b t ->
           f:(key:key ->
              data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
           unit

    val map : 'a t ->
           f:('a -> 'b) -> 'b t

    val mapi : 'a t ->
           f:(key:key -> data:'a -> 'b) ->
           'b t

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

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

    val filter : 'a t ->
           f:(key:key -> data:'a -> bool) ->
           'a t

    val filter_map : 'a t ->
           f:('a -> 'b option) -> 'b t

    val filter_mapi : 'a t ->
           f:(key:key -> data:'a -> 'b option) ->
           'b t

    val compare_direct : ('a -> 'a -> int) ->
           'a t -> 'a t -> int

    val equal : ('a -> 'a -> bool) ->
           'a t -> 'a t -> bool

    val keys : 'a t -> key list

    val data : 'a t -> 'a list

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

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

    val merge : 'a t ->
           'b t ->
           f:(key:key ->
              [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
           'c t

    val symmetric_diff : 'a t ->
           'a t ->
           data_equal:('a -> 'a -> bool) ->
           (key *
            [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
           Sequence.t

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

    val min_elt_exn : 'a t -> key * 'a

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

    val max_elt_exn : 'a t -> key * 'a

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

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

    val split : 'a t ->
           key ->
           'a t * (key * 'a) option *
           'a t

    val fold_range_inclusive : 'a t ->
           min:key ->
           max:key ->
           init:'b -> f:(key:key -> data:'a -> 'b -> 'b) -> 'b

    val range_to_alist : 'a t ->
           min:key ->
           max:key -> (key * 'a) list

    val closest_key : 'a t ->
           [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ] ->
           key -> (key * 'a) option

    val nth : 'a t ->
           int -> (key * 'a) option

    val rank : 'a t -> key -> int option

    val to_tree : 'a t -> 'a tree

    val to_sequence : ?order:[ `Decreasing_key | `Increasing_key ] ->
           ?keys_greater_or_equal_to:key ->
           ?keys_less_or_equal_to:key ->
           'a t ->
           (key * 'a) Sequence.t