package core

  1. Overview
  2. Docs
package core
Legend:
Library
Module
Module type
Parameter
Class
Class type
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
module Make (Key : sig ... end) : S with type key := Key.t with type comparator_witness := Key.comparator_witness
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct