Module Belt.MutableMap

Belt.MutableMap

The top level provides generic mutable map operations.

It also has two specialized inner modules Belt.MutableMap.Int and Belt.MutableMap.String

module Int : sig ... end

module Int: { ... };

module String : sig ... end

module String: { ... };

A mutable sorted map module which allows customize compare behavior.

Same as Belt.Map, but mutable.

type ('k, 'v, 'id) t

type t('k, 'v, 'id);

type ('key, 'id) id =
  (module Belt__.Belt_Id.Comparable
  with type identity = 'id
   and type t = 'key)

type id('key, 'id) =
  (module Belt__.Belt_Id.Comparable
  with type identity = 'id
   and type t = 'key);

val make : id:('k, 'id) id -> ('k, 'a, 'id) t

let make: id:id('k, 'id) => t('k, 'a, 'id);

val clear : (_, _, _) t -> unit

let clear: t(_, _, _) => unit;

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

let isEmpty: t(_, _, _) => bool;

val has : ('k, _, _) t -> 'k -> bool

let has: t('k, _, _) => 'k => bool;

val cmpU : 
  ('k, 'a, 'id) t ->
  ('k, 'a, 'id) t ->
  ('a -> 'a -> int) Js.Fn.arity2 ->
  int

let cmpU: 
  t('k, 'a, 'id) =>
  t('k, 'a, 'id) =>
  Js.Fn.arity2(('a => 'a => int)) =>
  int;

val cmp : ('k, 'a, 'id) t -> ('k, 'a, 'id) t -> ('a -> 'a -> int) -> int

let cmp: t('k, 'a, 'id) => t('k, 'a, 'id) => ('a => 'a => int) => int;

cmp m1 m2 cmp First compare by size, if size is the same, compare by key, value pair

val eqU : 
  ('k, 'a, 'id) t ->
  ('k, 'a, 'id) t ->
  ('a -> 'a -> bool) Js.Fn.arity2 ->
  bool

let eqU: 
  t('k, 'a, 'id) =>
  t('k, 'a, 'id) =>
  Js.Fn.arity2(('a => 'a => bool)) =>
  bool;

val eq : ('k, 'a, 'id) t -> ('k, 'a, 'id) t -> ('a -> 'a -> bool) -> bool

let eq: t('k, 'a, 'id) => t('k, 'a, 'id) => ('a => 'a => bool) => bool;

eq m1 m2 eqf tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. eqf is the equality predicate used to compare the data associated with the keys.

val forEachU : ('k, 'a, 'id) t -> ('k -> 'a -> unit) Js.Fn.arity2 -> unit

let forEachU: t('k, 'a, 'id) => Js.Fn.arity2(('k => 'a => unit)) => unit;

val forEach : ('k, 'a, 'id) t -> ('k -> 'a -> unit) -> unit

let forEach: t('k, 'a, 'id) => ('k => 'a => unit) => unit;

forEach m f applies f to all bindings in map m. f receives the 'k as first argument, and the associated value as second argument. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.

val reduceU : 
  ('k, 'a, 'id) t ->
  'b ->
  ('b -> 'k -> 'a -> 'b) Js.Fn.arity3 ->
  'b

let reduceU: 
  t('k, 'a, 'id) =>
  'b =>
  Js.Fn.arity3(('b => 'k => 'a => 'b)) =>
  'b;

val reduce : ('k, 'a, 'id) t -> 'b -> ('b -> 'k -> 'a -> 'b) -> 'b

let reduce: t('k, 'a, 'id) => 'b => ('b => 'k => 'a => 'b) => 'b;

reduce m a f computes (f kN dN ... (f k1 d1 a)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.

val everyU : ('k, 'a, 'id) t -> ('k -> 'a -> bool) Js.Fn.arity2 -> bool

let everyU: t('k, 'a, 'id) => Js.Fn.arity2(('k => 'a => bool)) => bool;

val every : ('k, 'a, 'id) t -> ('k -> 'a -> bool) -> bool

let every: t('k, 'a, 'id) => ('k => 'a => bool) => bool;

every m p checks if all the bindings of the map satisfy the predicate p.

val someU : ('k, 'a, 'id) t -> ('k -> 'a -> bool) Js.Fn.arity2 -> bool

let someU: t('k, 'a, 'id) => Js.Fn.arity2(('k => 'a => bool)) => bool;

val some : ('k, 'a, 'id) t -> ('k -> 'a -> bool) -> bool

let some: t('k, 'a, 'id) => ('k => 'a => bool) => bool;

some m p checks if at least one binding of the map satisfy the predicate p.

val size : ('k, 'a, 'id) t -> int

let size: t('k, 'a, 'id) => int;

val toList : ('k, 'a, 'id) t -> ('k * 'a) list

let toList: t('k, 'a, 'id) => list(('k, 'a));

In increasing order

val toArray : ('k, 'a, 'id) t -> ('k * 'a) array

let toArray: t('k, 'a, 'id) => array(('k, 'a));

In increasing order

val fromArray : ('k * 'a) array -> id:('k, 'id) id -> ('k, 'a, 'id) t

let fromArray: array(('k, 'a)) => id:id('k, 'id) => t('k, 'a, 'id);

val keysToArray : ('k, _, _) t -> 'k array

let keysToArray: t('k, _, _) => array('k);

val valuesToArray : (_, 'a, _) t -> 'a array

let valuesToArray: t(_, 'a, _) => array('a);

val minKey : ('k, _, _) t -> 'k option

let minKey: t('k, _, _) => option('k);

val minKeyUndefined : ('k, _, _) t -> 'k Js.undefined

let minKeyUndefined: t('k, _, _) => Js.undefined('k);

val maxKey : ('k, _, _) t -> 'k option

let maxKey: t('k, _, _) => option('k);

val maxKeyUndefined : ('k, _, _) t -> 'k Js.undefined

let maxKeyUndefined: t('k, _, _) => Js.undefined('k);

val minimum : ('k, 'a, _) t -> ('k * 'a) option

let minimum: t('k, 'a, _) => option(('k, 'a));

val minUndefined : ('k, 'a, _) t -> ('k * 'a) Js.undefined

let minUndefined: t('k, 'a, _) => Js.undefined(('k, 'a));

val maximum : ('k, 'a, _) t -> ('k * 'a) option

let maximum: t('k, 'a, _) => option(('k, 'a));

val maxUndefined : ('k, 'a, _) t -> ('k * 'a) Js.undefined

let maxUndefined: t('k, 'a, _) => Js.undefined(('k, 'a));

val get : ('k, 'a, 'id) t -> 'k -> 'a option

let get: t('k, 'a, 'id) => 'k => option('a);

val getUndefined : ('k, 'a, 'id) t -> 'k -> 'a Js.undefined

let getUndefined: t('k, 'a, 'id) => 'k => Js.undefined('a);

val getWithDefault : ('k, 'a, 'id) t -> 'k -> 'a -> 'a

let getWithDefault: t('k, 'a, 'id) => 'k => 'a => 'a;

val getExn : ('k, 'a, 'id) t -> 'k -> 'a

let getExn: t('k, 'a, 'id) => 'k => 'a;

val checkInvariantInternal : (_, _, _) t -> unit

let checkInvariantInternal: t(_, _, _) => unit;

raise when invariant is not held

val remove : ('k, 'a, 'id) t -> 'k -> unit

let remove: t('k, 'a, 'id) => 'k => unit;

remove m x do the in-place modification,

val removeMany : ('k, 'a, 'id) t -> 'k array -> unit

let removeMany: t('k, 'a, 'id) => array('k) => unit;

val set : ('k, 'a, 'id) t -> 'k -> 'a -> unit

let set: t('k, 'a, 'id) => 'k => 'a => unit;

set m x y do the in-place modification

val updateU : 
  ('k, 'a, 'id) t ->
  'k ->
  ('a option -> 'a option) Js.Fn.arity1 ->
  unit

let updateU: 
  t('k, 'a, 'id) =>
  'k =>
  Js.Fn.arity1((option('a) => option('a))) =>
  unit;

val update : ('k, 'a, 'id) t -> 'k -> ('a option -> 'a option) -> unit

let update: t('k, 'a, 'id) => 'k => (option('a) => option('a)) => unit;

val mergeMany : ('k, 'a, 'id) t -> ('k * 'a) array -> unit

let mergeMany: t('k, 'a, 'id) => array(('k, 'a)) => unit;

val mapU : ('k, 'a, 'id) t -> ('a -> 'b) Js.Fn.arity1 -> ('k, 'b, 'id) t

let mapU: t('k, 'a, 'id) => Js.Fn.arity1(('a => 'b)) => t('k, 'b, 'id);

val map : ('k, 'a, 'id) t -> ('a -> 'b) -> ('k, 'b, 'id) t

let map: t('k, 'a, 'id) => ('a => 'b) => t('k, 'b, 'id);

map m f returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a. The bindings are passed to f in increasing order with respect to the ordering over the type of the keys.

val mapWithKeyU : 
  ('k, 'a, 'id) t ->
  ('k -> 'a -> 'b) Js.Fn.arity2 ->
  ('k, 'b, 'id) t

let mapWithKeyU: 
  t('k, 'a, 'id) =>
  Js.Fn.arity2(('k => 'a => 'b)) =>
  t('k, 'b, 'id);

val mapWithKey : ('k, 'a, 'id) t -> ('k -> 'a -> 'b) -> ('k, 'b, 'id) t

let mapWithKey: t('k, 'a, 'id) => ('k => 'a => 'b) => t('k, 'b, 'id);