package mopsa

  1. Overview
  2. Docs
package mopsa
Legend:
Library
Module
Module type
Parameter
Class
Class type

Maps with polymorphic keys and values

type ('k, 'a) map =
  1. | Empty
  2. | Node of ('k, 'a) map * 'k * 'a * ('k, 'a) map * int
type 'k compare = 'k -> 'k -> int
type ('k, 'a) t = {
  1. map : ('k, 'a) map;
  2. compare : 'k compare;
}

Internal functions with compare parameter

*********************************************

val height_ : ('a, 'b) map -> int
val create_ : ('a, 'b) map -> 'c -> 'd -> ('a, 'b) map -> ('a, 'b) map
val singleton_ : 'a -> 'b -> ('c, 'd) map
val bal_ : ('a, 'b) map -> 'c -> 'd -> ('a, 'b) map -> ('e, 'f) map
val empty_ : ('a, 'b) map
val is_empty_ : ('a, 'b) map -> bool
val add_ : ('a -> 'b -> int) -> 'c -> 'd -> ('e, 'f) map -> ('e, 'f) map
val find_ : ('a -> 'b -> int) -> 'c -> ('d, 'e) map -> 'f
val find_opt_ : ('a -> 'b -> int) -> 'c -> ('d, 'e) map -> 'f option
val mem_ : ('a -> 'b -> int) -> 'c -> ('d, 'e) map -> bool
val min_binding_ : ('a, 'b) map -> 'c * 'd
val max_binding_ : ('a, 'b) map -> 'c * 'd
val remove_min_binding_ : ('a, 'b) map -> ('c, 'd) map
val remove_ : ('a -> 'b -> int) -> 'c -> ('d, 'e) map -> ('d, 'e) map
val map_ : ('a -> 'b) -> ('c, 'd) map -> ('e, 'f) map
val mapi_ : ('a -> 'b -> 'c) -> ('d, 'e) map -> ('f, 'g) map
val fold_ : ('a -> 'b -> 'c -> 'd) -> ('e, 'f) map -> 'g -> 'h
val for_all_ : ('a -> 'b -> bool) -> ('c, 'd) map -> bool
val exists_ : ('a -> 'b -> bool) -> ('c, 'd) map -> bool
val filter_ : ('a -> 'a -> int) -> ('b -> 'c -> bool) -> ('d, 'e) map -> ('a, 'f) map
val partition_ : ('a -> 'a -> int) -> ('b -> 'c -> bool) -> ('d, 'e) map -> ('f, 'g) map * ('a, 'h) map
val join_ : ('a -> 'a -> int) -> ('b, 'c) map -> 'd -> 'e -> ('b, 'c) map -> ('b, 'c) map
val concat_ : ('a -> 'a -> int) -> ('b, 'c) map -> ('b, 'c) map -> ('b, 'c) map
val concat_or_join_ : ('a -> 'a -> int) -> ('a, 'b) map -> 'c -> 'd option -> ('a, 'b) map -> ('a, 'b) map
val of_list_ : ('a -> 'a -> int) -> ('b * 'c) list -> ('a, 'd) map
val cut_ : ('a -> 'b -> int) -> 'c -> ('d, 'e) map -> ('f, 'g) map * 'h option * ('i, 'j) map
val for_all2zo_ : ('a -> 'b -> int) -> ('c -> 'd -> bool) -> ('e -> 'f -> bool) -> ('g -> 'h -> 'i -> bool) -> ('b, 'j) map -> ('b, 'j) map -> bool
val map2zo_ : ('a -> 'a -> int) -> ('b -> 'c -> 'd) -> ('e -> 'f -> 'g) -> ('h -> 'i -> 'j -> 'k) -> ('a, 'l) map -> ('a, 'l) map -> ('a, 'l) map
val split_ : ('a -> 'a -> int) -> 'b -> ('c, 'd) map -> ('a, 'e) map * 'f option * ('g, 'h) map
val merge_ : ('a -> 'a -> int) -> ('b -> 'c option -> 'd option -> 'e option) -> ('f, 'g) map -> ('h, 'd) map -> ('a, 'e) map
val bindings_aux_ : ('a * 'b) list -> ('c, 'd) map -> ('a * 'b) list
val bindings_ : ('a, 'b) map -> ('a * 'b) list
val cardinal_ : ('a, 'b) map -> int
val fold2zo_ : ('a -> 'b -> int) -> ('c -> 'd -> 'e -> 'f) -> ('g -> 'h -> 'i -> 'i) -> ('j -> 'k -> 'l -> 'm -> 'n) -> ('b, 'o) map -> ('b, 'o) map -> 'p -> 'q
val fold2o_ : ('a -> 'b -> int) -> ('c -> 'd -> 'e -> 'f) -> ('g -> 'h -> 'i -> 'i) -> ('j -> 'k -> 'l -> 'm -> 'n) -> ('o, 'p) map -> ('b, 'q) map -> 'r -> 's
val iter_ : ('a -> 'b -> 'c) -> ('d, 'e) map -> unit
val iter2zo_ : ('a -> 'b -> int) -> ('c -> 'd -> unit) -> ('e -> 'f -> 'g) -> ('h -> 'i -> 'j -> unit) -> ('b, 'k) map -> ('b, 'k) map -> unit
val compare_ : ('a -> 'a -> int) -> ('b -> 'c -> int) -> ('a, 'd) map -> ('a, 'd) map -> int

Exported functions

**********************

val singleton : compare:'a compare -> 'b -> 'c -> ('d, 'e) t
val empty : compare:'a compare -> ('b, 'c) t
val is_empty : ('a, 'b) t -> bool
val add : 'a -> 'b -> ('c, 'd) t -> ('c, 'd) t
val find : 'a -> ('b, 'c) t -> 'd
val find_opt : 'a -> ('b, 'c) t -> 'd option
val mem : 'a -> ('b, 'c) t -> bool
val min_binding : ('a, 'b) t -> 'c * 'd
val remove_min_binding : ('a, 'b) t -> ('c, 'd) t
val remove : 'a -> ('b, 'c) t -> ('b, 'c) t
val max_binding : ('a, 'b) t -> 'c * 'd
val iter : ('a -> 'b -> 'c) -> ('d, 'e) t -> unit
val map : ('a -> 'b) -> ('c, 'd) t -> ('e, 'f) t
val mapi : ('a -> 'b -> 'c) -> ('d, 'e) t -> ('f, 'g) t
val fold : ('a -> 'b -> 'c -> 'c) -> ('d, 'e) t -> 'f -> 'g
val for_all : ('a -> 'b -> bool) -> ('c, 'd) t -> bool
val exists : ('a -> 'b -> bool) -> ('c, 'd) t -> bool
val filter : ('a -> 'b -> bool) -> ('c, 'd) t -> ('c, 'd) t
val partition : ('a -> 'b -> bool) -> ('c, 'd) t -> ('c, 'd) t * ('c, 'd) t
val for_all2zo : ('a -> 'b -> bool) -> ('a -> 'b -> bool) -> ('a -> 'b -> 'b -> bool) -> ('c, 'd) t -> ('e, 'f) t -> bool
val map2zo : ('a -> 'b -> 'b) -> ('a -> 'b -> 'b) -> ('a -> 'b -> 'b -> 'b) -> ('c, 'd) t -> ('c, 'd) t -> ('c, 'd) t
val merge : ('a -> 'b option -> 'c option -> 'd option) -> ('e, 'f) t -> ('g, 'h) t -> ('i, 'j) t
val bindings : ('a, 'b) t -> ('c * 'd) list
val cardinal : ('a, 'b) t -> int
val fold2zo : ('a -> 'b -> 'c -> 'c) -> ('a -> 'b -> 'c -> 'c) -> ('a -> 'b -> 'b -> 'c -> 'c) -> ('d, 'e) t -> ('f, 'g) t -> 'h -> 'i
val fold2o : ('a -> 'b -> 'c -> 'c) -> ('d -> 'e -> 'c -> 'c) -> ('a -> 'b -> 'e -> 'c -> 'c) -> ('f, 'g) t -> ('h, 'i) t -> 'j -> 'k
val compare : ('a -> 'a -> int) -> ('b, 'c) t -> ('d, 'e) t -> int
val of_list : 'a compare -> ('b * 'c) list -> ('d, 'e) t
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