Module Set.Dict

This module seprate identity from data, it is a bit more verboe but slightly more efficient due to the fact that there is no need to pack identity and data back after each operation

type ('value, 'identity) t

type t('value, 'identity);

type ('value, 'id) cmp

type cmp('value, 'id);

val empty : ('value, 'id) t

let empty: t('value, 'id);

val fromArray : 'value array -> cmp:('value, 'id) cmp -> ('value, 'id) t

let fromArray: array('value) => cmp:cmp('value, 'id) => t('value, 'id);

val fromSortedArrayUnsafe : 'value array -> ('value, 'id) t

let fromSortedArrayUnsafe: array('value) => t('value, 'id);

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

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

val has : ('value, 'id) t -> 'value -> cmp:('value, 'id) cmp -> bool

let has: t('value, 'id) => 'value => cmp:cmp('value, 'id) => bool;

val add : ('value, 'id) t -> 'value -> cmp:('value, 'id) cmp -> ('value, 'id) t

let add: t('value, 'id) => 'value => cmp:cmp('value, 'id) => t('value, 'id);

add s x If x was already in s, s is returned unchanged.

val mergeMany : 
  ('value, 'id) t ->
  'value array ->
  cmp:('value, 'id) cmp ->
  ('value, 'id) t

let mergeMany: 
  t('value, 'id) =>
  array('value) =>
  cmp:cmp('value, 'id) =>
  t('value, 'id);

val remove : 
  ('value, 'id) t ->
  'value ->
  cmp:('value, 'id) cmp ->
  ('value, 'id) t

let remove: t('value, 'id) => 'value => cmp:cmp('value, 'id) => t('value, 'id);

remove m x If x was not in m, m is returned reference unchanged.

val removeMany : 
  ('value, 'id) t ->
  'value array ->
  cmp:('value, 'id) cmp ->
  ('value, 'id) t

let removeMany: 
  t('value, 'id) =>
  array('value) =>
  cmp:cmp('value, 'id) =>
  t('value, 'id);

val union : 
  ('value, 'id) t ->
  ('value, 'id) t ->
  cmp:('value, 'id) cmp ->
  ('value, 'id) t

let union: 
  t('value, 'id) =>
  t('value, 'id) =>
  cmp:cmp('value, 'id) =>
  t('value, 'id);

val intersect : 
  ('value, 'id) t ->
  ('value, 'id) t ->
  cmp:('value, 'id) cmp ->
  ('value, 'id) t

let intersect: 
  t('value, 'id) =>
  t('value, 'id) =>
  cmp:cmp('value, 'id) =>
  t('value, 'id);

val diff : 
  ('value, 'id) t ->
  ('value, 'id) t ->
  cmp:('value, 'id) cmp ->
  ('value, 'id) t

let diff: 
  t('value, 'id) =>
  t('value, 'id) =>
  cmp:cmp('value, 'id) =>
  t('value, 'id);

val subset : 
  ('value, 'id) t ->
  ('value, 'id) t ->
  cmp:('value, 'id) cmp ->
  bool

let subset: t('value, 'id) => t('value, 'id) => cmp:cmp('value, 'id) => bool;

subset s1 s2 tests whether the set s1 is a subset of the set s2.

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

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

Total ordering between sets. Can be used as the ordering function for doing sets of sets.

val eq : ('value, 'id) t -> ('value, 'id) t -> cmp:('value, 'id) cmp -> bool

let eq: t('value, 'id) => t('value, 'id) => cmp:cmp('value, 'id) => bool;

eq s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.

val forEachU : ('value, 'id) t -> ('value -> unit) Js.Fn.arity1 -> unit

let forEachU: t('value, 'id) => Js.Fn.arity1(('value => unit)) => unit;

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

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

forEach s f applies f in turn to all elements of s. In increasing order

val reduceU : ('value, 'id) t -> 'a -> ('a -> 'value -> 'a) Js.Fn.arity2 -> 'a

let reduceU: t('value, 'id) => 'a => Js.Fn.arity2(('a => 'value => 'a)) => 'a;

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

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

Iterate in increasing order.

val everyU : ('value, 'id) t -> ('value -> bool) Js.Fn.arity1 -> bool

let everyU: t('value, 'id) => Js.Fn.arity1(('value => bool)) => bool;

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

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

every p s checks if all elements of the set satisfy the predicate p. Order unspecified.

val someU : ('value, 'id) t -> ('value -> bool) Js.Fn.arity1 -> bool

let someU: t('value, 'id) => Js.Fn.arity1(('value => bool)) => bool;

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

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

some p s checks if at least one element of the set satisfies the predicate p. Oder unspecified.

val keepU : ('value, 'id) t -> ('value -> bool) Js.Fn.arity1 -> ('value, 'id) t

let keepU: t('value, 'id) => Js.Fn.arity1(('value => bool)) => t('value, 'id);

val keep : ('value, 'id) t -> ('value -> bool) -> ('value, 'id) t

let keep: t('value, 'id) => ('value => bool) => t('value, 'id);

keep p s returns the set of all elements in s that satisfy predicate p.

val partitionU : 
  ('value, 'id) t ->
  ('value -> bool) Js.Fn.arity1 ->
  ('value, 'id) t * ('value, 'id) t

let partitionU: 
  t('value, 'id) =>
  Js.Fn.arity1(('value => bool)) =>
  (t('value, 'id), t('value, 'id));

val partition : 
  ('value, 'id) t ->
  ('value -> bool) ->
  ('value, 'id) t * ('value, 'id) t

let partition: 
  t('value, 'id) =>
  ('value => bool) =>
  (t('value, 'id), t('value, 'id));

partition p s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate p, and s2 is the set of all the elements of s that do not satisfy p.

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

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

val toList : ('value, 'id) t -> 'value list

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

In increasing order

val toArray : ('value, 'id) t -> 'value array

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

val minimum : ('value, 'id) t -> 'value option

let minimum: t('value, 'id) => option('value);

val minUndefined : ('value, 'id) t -> 'value Js.undefined

let minUndefined: t('value, 'id) => Js.undefined('value);

val maximum : ('value, 'id) t -> 'value option

let maximum: t('value, 'id) => option('value);

val maxUndefined : ('value, 'id) t -> 'value Js.undefined

let maxUndefined: t('value, 'id) => Js.undefined('value);

val get : ('value, 'id) t -> 'value -> cmp:('value, 'id) cmp -> 'value option

let get: t('value, 'id) => 'value => cmp:cmp('value, 'id) => option('value);

val getUndefined : 
  ('value, 'id) t ->
  'value ->
  cmp:('value, 'id) cmp ->
  'value Js.undefined

let getUndefined: 
  t('value, 'id) =>
  'value =>
  cmp:cmp('value, 'id) =>
  Js.undefined('value);

val getExn : ('value, 'id) t -> 'value -> cmp:('value, 'id) cmp -> 'value

let getExn: t('value, 'id) => 'value => cmp:cmp('value, 'id) => 'value;

val split : 
  ('value, 'id) t ->
  'value ->
  cmp:('value, 'id) cmp ->
  (('value, 'id) t * ('value, 'id) t) * bool

let split: 
  t('value, 'id) =>
  'value =>
  cmp:cmp('value, 'id) =>
  ((t('value, 'id), t('value, 'id)), bool);

split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.

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

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

raise when invariant is not held