Map (melange.Melange_compiler_libs.Shape.Uid.Map)

type key = T.t;

type t(!'a) = Stdlib.Map.Make(T).t('a);

let empty: t('a);

let add: key => 'a => t('a) => t('a);

let add_to_list: key => 'a => t(list('a)) => t(list('a));

let update: key => (option('a) => option('a)) => t('a) => t('a);

let singleton: key => 'a => t('a);

let remove: key => t('a) => t('a);

let merge: 
  (key => option('a) => option('b) => option('c)) =>
  t('a) =>
  t('b) =>
  t('c);

let union: (key => 'a => 'a => option('a)) => t('a) => t('a) => t('a);

let cardinal: t('a) => int;

let bindings: t('a) => list((key, 'a));

let min_binding: t('a) => (key, 'a);

let min_binding_opt: t('a) => option((key, 'a));

let max_binding: t('a) => (key, 'a);

let max_binding_opt: t('a) => option((key, 'a));

let choose: t('a) => (key, 'a);

let choose_opt: t('a) => option((key, 'a));

let find: key => t('a) => 'a;

let find_opt: key => t('a) => option('a);

let find_first: (key => bool) => t('a) => (key, 'a);

let find_first_opt: (key => bool) => t('a) => option((key, 'a));

let find_last: (key => bool) => t('a) => (key, 'a);

let find_last_opt: (key => bool) => t('a) => option((key, 'a));

let iter: (key => 'a => unit) => t('a) => unit;

let fold: (key => 'a => 'acc => 'acc) => t('a) => 'acc => 'acc;

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

let mapi: (key => 'a => 'b) => t('a) => t('b);

let filter: (key => 'a => bool) => t('a) => t('a);

let filter_map: (key => 'a => option('b)) => t('a) => t('b);

let partition: (key => 'a => bool) => t('a) => (t('a), t('a));

let split: key => t('a) => (t('a), option('a), t('a));

let is_empty: t('a) => bool;

let mem: key => t('a) => bool;

let equal: ('a => 'a => bool) => t('a) => t('a) => bool;

let compare: ('a => 'a => int) => t('a) => t('a) => int;

let for_all: (key => 'a => bool) => t('a) => bool;

let exists: (key => 'a => bool) => t('a) => bool;

let to_list: t('a) => list((key, 'a));

let to_seq: t('a) => Stdlib.Seq.t((key, 'a));

let to_rev_seq: t('a) => Stdlib.Seq.t((key, 'a));

let to_seq_from: key => t('a) => Stdlib.Seq.t((key, 'a));

let add_seq: Stdlib.Seq.t((key, 'a)) => t('a) => t('a);

let of_seq: Stdlib.Seq.t((key, 'a)) => t('a);

let of_list: list((key, 'a)) => t('a);

let disjoint_union: 
  ?eq:('a => 'a => bool) =>
  ?print:(Stdlib.Format.formatter => 'a => unit) =>
  t('a) =>
  t('a) =>
  t('a);

let union_right: t('a) => t('a) => t('a);

let union_left: t('a) => t('a) => t('a);

let union_merge: ('a => 'a => 'a) => t('a) => t('a) => t('a);

let rename: t(key) => key => key;

let map_keys: (key => key) => t('a) => t('a);

let keys: t('a) => Stdlib.Set.Make(T).t;

let data: t('a) => list('a);

let of_set: (key => 'a) => Stdlib.Set.Make(T).t => t('a);

let transpose_keys_and_data: t(key) => t(key);

let transpose_keys_and_data_set: t(key) => t(Stdlib.Set.Make(T).t);

let print: 
  (Stdlib.Format.formatter => 'a => unit) =>
  Stdlib.Format.formatter =>
  t('a) =>
  unit;