package containers

You can search for identifiers within the package.

in-package search v0.2.0

package containers

containers
- CCArray
  - Infix
  - MONO_ARRAY
- CCArrayLabels
- CCBool
- CCChar
- CCEqual
  - Infix
- CCEqualLabels
  - Infix
- CCFloat
  - Infix
- CCFormat
  - Dump
- CCFun
  - Infix
  - Monad
    
    X
- CCHash
- CCHashtbl
  - Make
  - Poly
  - S
- CCHeap
  - Make
    
    E
  - Make_from_compare
    
    E
  - PARTIAL_ORD
  - S
  - TOTAL_ORD
- CCIO
  - File
- CCInt
  - Infix
- CCInt32
  - Infix
- CCInt64
  - Infix
- CCList
  - Assoc
  - Infix
  - MONAD
  - Ref
  - Traverse
    
    M
- CCListLabels
  - Assoc
  - Infix
  - MONAD
  - Ref
  - Traverse
    
    M
- CCMap
  - Make
  - S
- CCNativeint
  - Infix
- CCOpt
  - Infix
- CCOrd
  - Infix
- CCPair
- CCParse
  - Infix
  - U
- CCRandom
- CCRef
- CCResult
  - Infix
  - MONAD
  - Traverse
    
    M
- CCSeq
  - Infix
  - MONAD
  - Traverse
    
    M
- CCSet
  - Make
  - S
- CCSexp
  - Decoder
  - Make
    
    Decoder
    
    Sexp
- CCSexp_intf
  - S
    
    Decoder
  - SEXP
- CCSexp_lex
- CCShimsArrayLabels_
  - Floatarray
- CCShimsArray_
- CCShimsFormat_
- CCShimsFun_
- CCShimsInt_
- CCShimsList_
- CCShimsMkLet_
  - Make
    
    X
  - Make2
    
    X
  - S
  - S2
- CCShims_
- CCString
  - Find
  - Infix
  - Split
- CCStringLabels
  - Find
  - Infix
  - Split
- CCUtf8_string
- CCVector
- Containers
  - Hashtbl
    
    HashedType
    
    Make
    
    MakeSeeded
    
    H
    
    S
    
    SeededHashedType
    
    SeededS
- ContainersLabels
  - Hashtbl
    
    HashedType
    
    Make
    
    MakeSeeded
    
    H
    
    S
    
    SeededHashedType
    
    SeededS
containers.monomorphic
- CCMonomorphic
- CCMonomorphicShims_
containers.top
- Containers_top
containers.unix
- CCUnix
  - Infix

Legend:
Library
Module
Module type
Parameter
Class
Class type

include Stdlib.Map.S

type key

type !+'a t

val empty : 'a t

val is_empty : 'a t -> bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t

val cardinal : 'a t -> int

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

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

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

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

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

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

val find_last : (key -> bool) -> 'a t -> key * 'a

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

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

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

val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t

val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.t

val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.t

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

get k m returns Some v if the current binding of k in m is v, or None if the key k is not present. Safe version of find.

val get_or : key -> 'a t -> default:'a -> 'a

get_or k m ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in m).

since 0.16

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

update k f m calls f (Some v) if find k m = v, otherwise it calls f None. In any case, if the result is None k is removed from m, and if the result is Some v' then add k v' m is returned.

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

choose_opt m returns one binding of the given map m, or None if m is empty. Safe version of choose.

since 1.5

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

min_binding_opt m returns the smallest binding of the given map m, or None if m is empty. Safe version of min_binding.

since 1.5

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

max_binding_opt m returns the largest binding of the given map m, or None if m is empty. Safe version of max_binding.

since 1.5

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

find_opt k m returns Some v if the current binding of k in m is v, or None if the key k is not present. Safe version of find.

since 1.5

val find_first : (key -> bool) -> 'a t -> key * 'a

find_first f m where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists. See Map.S.find_first.

since 1.5

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

find_first_opt f m where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists. Safe version of find_first.

since 1.5

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

merge_safe ~f a b merges the maps a and b together.

since 0.17

val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> 'a t

add_seq m seq adds the given Seq.t of bindings to the map m. Like add_list. Renamed from add_std_seq since 3.0.

since 3.0

val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t

of_seq seq builds a map from the given Seq.t of bindings. Like of_list. Renamed from of_std_seq since 3.0.

since 3.0

val add_iter : 'a t -> (key * 'a) iter -> 'a t

add_iter m iter adds the given iter of bindings to the map m. Like add_list.

since 2.8

val of_iter : (key * 'a) iter -> 'a t

of_iter iter builds a map from the given iter of bindings. Like of_list.

since 2.8

val to_iter : 'a t -> (key * 'a) iter

to_iter m iterates on the whole map m, creating an iter of bindings. Like to_list.

since 2.8

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

of_list l builds a map from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, only its last binding will be present in the result.

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

add_list m l adds the given list l of bindings to the map m.

since 0.14

val keys : _ t -> key iter

keys m iterates on the keys of m only, creating an iter of keys.

since 0.15

val values : 'a t -> 'a iter

values m iterates on the values of m only, creating an iter of values.

since 0.15

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

to_list m builds a list of the bindings of the given map m.

val pp : 
  ?pp_start:unit printer ->
  ?pp_stop:unit printer ->
  ?pp_arrow:unit printer ->
  ?pp_sep:unit printer ->
  key printer ->
  'a printer ->
  'a t printer

pp ?pp_start ?pp_stop ?pp_arrow ?pp_sep pp_key pp_v m pretty-prints the contents of the map.