package containers

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

Parameters

module X : ORD

Signature

type key = X.t
type +'a t
val empty : 'a t
val is_empty : _ t -> bool
val singleton : key -> 'a -> 'a t
val mem : key -> _ t -> bool
val get : key -> 'a t -> 'a option
val get_exn : key -> 'a t -> 'a
  • raises Not_found

    if the key is not present

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

nth i m returns the i-th key, value in the ascending order. Complexity is O(log (cardinal m))

val nth_exn : int -> 'a t -> key * 'a
  • raises Not_found

    if the index is invalid

val add : key -> 'a -> 'a t -> 'a t
val remove : key -> 'a t -> 'a t
val update : key -> ('a option -> 'a option) -> 'a t -> 'a t

update k f m calls f (Some v) if get k m = Some v, f None otherwise. Then, if f returns Some v' it binds k to v', if f returns None it removes k

val cardinal : _ t -> int
val weight : _ t -> int
val fold : f:('b -> key -> 'a -> 'b) -> x:'b -> 'a t -> 'b
val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t

Map values, giving both key and value. Will use WORD.of_list to rebuild keys.

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

Map values, giving only the value.

  • since 0.17
val iter : f:(key -> 'a -> unit) -> 'a t -> unit
val split : key -> 'a t -> 'a t * 'a option * 'a t

split k t returns l, o, r where l is the part of the map with keys smaller than k, r has keys bigger than k, and o = Some v if k, v belonged to the map

val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t

Similar to Map.S.merge

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

extract_min m returns k, v, m' where k,v is the pair with the smallest key in m, and m' does not contain k.

  • raises Not_found

    if the map is empty

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

extract_max m returns k, v, m' where k,v is the pair with the highest key in m, and m' does not contain k.

  • raises Not_found

    if the map is empty

val choose : 'a t -> (key * 'a) option
val choose_exn : 'a t -> key * 'a
  • raises Not_found

    if the tree is empty

val random_choose : Random.State.t -> 'a t -> key * 'a

Randomly choose a (key,value) pair within the tree, using weights as probability weights

  • raises Not_found

    if the tree is empty

val add_list : 'a t -> (key * 'a) list -> 'a t
val of_list : (key * 'a) list -> 'a t
val to_list : 'a t -> (key * 'a) list
val add_seq : 'a t -> (key * 'a) sequence -> 'a t
val of_seq : (key * 'a) sequence -> 'a t
val to_seq : 'a t -> (key * 'a) sequence
val add_gen : 'a t -> (key * 'a) gen -> 'a t
val of_gen : (key * 'a) gen -> 'a t
val to_gen : 'a t -> (key * 'a) gen
val print : key printer -> 'a printer -> 'a t printer
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