V1 (docs.findlib-1.core.Core.Map.Stable.V1)

type nonrec ('a, 'b, 'c) t = ('a, 'b, 'c) t

module type S = sig ... end

include Map_intf.For_deriving with type ('a, 'b, 'c) t := ('a, 'b, 'c) t

include Base.Map.For_deriving with type ('a, 'b, 'c) t := ('a, 'b, 'c) t

module type Sexp_of_m = sig ... end

module type M_of_sexp = sig ... end

module type M_sexp_grammar = sig ... end

module type Compare_m = sig ... end

module type Equal_m = sig ... end

module type Hash_fold_m = Base.Hasher.S

val sexp_of_m__t : 
  (module Sexp_of_m with type t = 'k) ->
  ('v -> Base.Sexp.t) ->
  ('k, 'v, 'cmp) t ->
  Base.Sexp.t

val m__t_of_sexp : 
  (module M_of_sexp with type comparator_witness = 'cmp and type t = 'k) ->
  (Base.Sexp.t -> 'v) ->
  Base.Sexp.t ->
  ('k, 'v, 'cmp) t

val m__t_sexp_grammar : 
  (module M_sexp_grammar with type t = 'k) ->
  'v Sexplib0.Sexp_grammar.t ->
  ('k, 'v, 'cmp) t Sexplib0.Sexp_grammar.t

val compare_m__t : 
  (module Compare_m) ->
  ('v -> 'v -> int) ->
  ('k, 'v, 'cmp) t ->
  ('k, 'v, 'cmp) t ->
  int

val equal_m__t : 
  (module Equal_m) ->
  ('v -> 'v -> bool) ->
  ('k, 'v, 'cmp) t ->
  ('k, 'v, 'cmp) t ->
  bool

val hash_fold_m__t : 
  (module Hash_fold_m with type t = 'k) ->
  (Base.Hash.state -> 'v -> Base.Hash.state) ->
  Base.Hash.state ->
  ('k, 'v, _) t ->
  Base.Hash.state

module M = Base.Map.M

The following *bin* functions support bin-io on base-style maps, e.g.:

 type t = int Map.M(String).t [@@deriving bin_io]

val bin_shape_m__t : 
  ('a, 'c) Map_intf.Key_bin_io.t ->
  Bin_prot.Shape.t ->
  Bin_prot.Shape.t

val bin_size_m__t : 
  ('a, 'c) Map_intf.Key_bin_io.t ->
  'b Bin_prot.Size.sizer ->
  ('a, 'b, 'c) t Bin_prot.Size.sizer

val bin_write_m__t : 
  ('a, 'c) Map_intf.Key_bin_io.t ->
  'b Bin_prot.Write.writer ->
  ('a, 'b, 'c) t Bin_prot.Write.writer

val bin_read_m__t : 
  ('a, 'c) Map_intf.Key_bin_io.t ->
  'b Bin_prot.Read.reader ->
  ('a, 'b, 'c) t Bin_prot.Read.reader

val __bin_read_m__t__ : 
  ('a, 'c) Map_intf.Key_bin_io.t ->
  'b Bin_prot.Read.reader ->
  (Base.Int.t -> ('a, 'b, 'c) t) Bin_prot.Read.reader

The following quickcheck* functions support deriving quickcheck on base-style maps, e.g.:

 type t = int Map.M(String).t [@@deriving quickcheck]

module type Quickcheck_generator_m = sig ... end

module type Quickcheck_observer_m = sig ... end

module type Quickcheck_shrinker_m = sig ... end

val quickcheck_generator_m__t : 
  (module Quickcheck_generator_m
    with type comparator_witness = 'cmp
     and type t = 'k) ->
  'v Quickcheck.Generator.t ->
  ('k, 'v, 'cmp) t Quickcheck.Generator.t

val quickcheck_observer_m__t : 
  (module Quickcheck_observer_m
    with type comparator_witness = 'cmp
     and type t = 'k) ->
  'v Quickcheck.Observer.t ->
  ('k, 'v, 'cmp) t Quickcheck.Observer.t

val quickcheck_shrinker_m__t : 
  (module Quickcheck_shrinker_m
    with type comparator_witness = 'cmp
     and type t = 'k) ->
  'v Quickcheck.Shrinker.t ->
  ('k, 'v, 'cmp) t Quickcheck.Shrinker.t

include Map_intf.For_deriving_stable with type ('a, 'b, 'c) t := ('a, 'b, 'c) t

module type Stable_witness_m = sig ... end

val stable_witness_m__t : 
  (module Stable_witness_m with type comparator_witness = 'cmp and type t = 'k) ->
  'v Stable_witness.t ->
  ('k, 'v, 'cmp) t Stable_witness.t

module Make
  (Key : sig ... end) : 
  S
    with type key := Key.t
    with type comparator_witness := Key.comparator_witness

module With_stable_witness : sig ... end