SMap (melange.Js_parser.Object

type key = String.t;

type 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 of_list: list((key, 'a)) => t('a);

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

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

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

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

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