base v0.10.0 · OCaml Package

base

type ('a, 'b) t

type ('a, 'b) tree

val invariants : (_, _) t -> bool

val is_empty : (_, _) t -> bool

val length : (_, _) t -> int

val add : ('a, 'b) t -> key:'a -> data:'b -> ('a, 'b) t

deprecated [since 2017-11] Use [set] instead

val set : ('a, 'b) t -> key:'a -> data:'b -> ('a, 'b) t

val add_multi : ('a, 'b list) t -> key:'a -> data:'b -> ('a, 'b list) t

val remove_multi : ('a, 'b list) t -> 'a -> ('a, 'b list) t

val find_multi : ('a, 'b list) t -> 'a -> 'b list

val change : ('a, 'b) t -> 'a -> f:('b option -> 'b option) -> ('a, 'b) t

val update : ('a, 'b) t -> 'a -> f:('b option -> 'b) -> ('a, 'b) t

val find : ('a, 'b) t -> 'a -> 'b option

val find_exn : ('a, 'b) t -> 'a -> 'b

val remove : ('a, 'b) t -> 'a -> ('a, 'b) t

val mem : ('a, 'b) t -> 'a -> bool

val iter_keys : ('a, _) t -> f:('a -> unit) -> unit

val iter : (_, 'b) t -> f:('b -> unit) -> unit

val iteri : ('a, 'b) t -> f:(key:'a -> data:'b -> unit) -> unit

val iter2 : 
  ('a, 'b) t ->
  ('a, 'c) t ->
  f:(key:'a -> data:[ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> unit) ->
  unit

val map : ('a, 'b) t -> f:('b -> 'c) -> ('a, 'c) t

val mapi : ('a, 'b) t -> f:(key:'a -> data:'b -> 'c) -> ('a, 'c) t

val fold : ('a, 'b) t -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c

val fold_right : 
  ('a, 'b) t ->
  init:'c ->
  f:(key:'a -> data:'b -> 'c -> 'c) ->
  'c

val fold2 : 
  ('a, 'b) t ->
  ('a, 'c) t ->
  init:'d ->
  f:
    (key:'a ->
      data:[ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] ->
      'd ->
      'd) ->
  'd

val filter_keys : ('a, 'b) t -> f:('a -> bool) -> ('a, 'b) t

val filter : ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t

val filteri : ('a, 'b) t -> f:(key:'a -> data:'b -> bool) -> ('a, 'b) t

val filter_map : ('a, 'b) t -> f:('b -> 'c option) -> ('a, 'c) t

val filter_mapi : 
  ('a, 'b) t ->
  f:(key:'a -> data:'b -> 'c option) ->
  ('a, 'c) t

val partition_mapi : 
  ('a, 'b) t ->
  f:(key:'a -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
  ('a, 'c) t * ('a, 'd) t

val partition_map : 
  ('a, 'b) t ->
  f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
  ('a, 'c) t * ('a, 'd) t

val partitioni_tf : 
  ('a, 'b) t ->
  f:(key:'a -> data:'b -> bool) ->
  ('a, 'b) t * ('a, 'b) t

val partition_tf : ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t * ('a, 'b) t

val compare_direct : ('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int

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

val keys : ('a, _) t -> 'a list

val data : (_, 'b) t -> 'b list

val to_alist : 
  ?key_order:[ `Increasing | `Decreasing ] ->
  ('a, 'b) t ->
  ('a * 'b) list

val validate : 
  name:('a -> string) ->
  'b Validate.check ->
  ('a, 'b) t Validate.check

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

val symmetric_diff : 
  ('a, 'b) t ->
  ('a, 'b) t ->
  data_equal:('b -> 'b -> bool) ->
  ('a, 'b) Symmetric_diff_element.t Sequence.t

val min_elt : ('a, 'b) t -> ('a * 'b) option

val min_elt_exn : ('a, 'b) t -> 'a * 'b

val max_elt : ('a, 'b) t -> ('a * 'b) option

val max_elt_exn : ('a, 'b) t -> 'a * 'b

val for_all : (_, 'b) t -> f:('b -> bool) -> bool

val for_alli : ('a, 'b) t -> f:(key:'a -> data:'b -> bool) -> bool

val exists : (_, 'b) t -> f:('b -> bool) -> bool

val existsi : ('a, 'b) t -> f:(key:'a -> data:'b -> bool) -> bool

val count : (_, 'b) t -> f:('b -> bool) -> int

val counti : ('a, 'b) t -> f:(key:'a -> data:'b -> bool) -> int

val split : ('a, 'b) t -> 'a -> ('a, 'b) t * ('a * 'b) option * ('a, 'b) t

val append : 
  lower_part:('a, 'b) t ->
  upper_part:('a, 'b) t ->
  [ `Ok of ('a, 'b) t | `Overlapping_key_ranges ]

val subrange : 
  ('a, 'b) t ->
  lower_bound:'a Maybe_bound.t ->
  upper_bound:'a Maybe_bound.t ->
  ('a, 'b) t

val fold_range_inclusive : 
  ('a, 'b) t ->
  min:'a ->
  max:'a ->
  init:'c ->
  f:(key:'a -> data:'b -> 'c -> 'c) ->
  'c

val range_to_alist : ('a, 'b) t -> min:'a -> max:'a -> ('a * 'b) list

val closest_key : 
  ('a, 'b) t ->
  [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ] ->
  'a ->
  ('a * 'b) option

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

val nth_exn : ('a, 'b) t -> int -> 'a * 'b

val rank : ('a, _) t -> 'a -> int option

val to_tree : ('a, 'b) t -> ('a, 'b) tree

val to_sequence : 
  ?order:[ `Increasing_key | `Decreasing_key ] ->
  ?keys_greater_or_equal_to:'a ->
  ?keys_less_or_equal_to:'a ->
  ('a, 'b) t ->
  ('a * 'b) Sequence.t

package base