Module MutableSet.Int

Specalized when key type is int, more efficient than the generic type

This module is Belt.MutableSet specialized with key type to be a primitive type.

It is more efficient in general, the API is the same with Belt.MutableSet except its key type is fixed, and identity is not needed(using the built-in one)

See Belt.MutableSet

type value = int;

The type of the set elements.

type t;

The type of sets.

let make: unit => t;

let fromArray: array(value) => t;

let fromSortedArrayUnsafe: array(value) => t;

let copy: t => t;

let isEmpty: t => bool;

let has: t => value => bool;

let add: t => value => unit;

let addCheck: t => value => bool;

let mergeMany: t => array(value) => unit;

let remove: t => value => unit;

let removeCheck: t => value => bool;

let removeMany: t => array(value) => unit;

let union: t => t => t;

let intersect: t => t => t;

let diff: t => t => t;

let subset: t => t => bool;

let cmp: t => t => int;

let eq: t => t => bool;

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

let forEach: t => (value => unit) => unit;

In increasing order

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

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

Iterate in increasing order.

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

let every: t => (value => bool) => bool;

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

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

let some: t => (value => bool) => bool;

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

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

let keep: t => (value => bool) => t;

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

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

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

partition s p returns a fresh copy 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.

let size: t => int;

let toList: t => list(value);

In increasing order with respect

let toArray: t => array(value);

In increasing order with respect

let minimum: t => option(value);

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

let maximum: t => option(value);

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

let get: t => value => option(value);

let getUndefined: t => value => Js.undefined(value);

let getExn: t => value => value;

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

split s key return a fresh copy of each

let checkInvariantInternal: t => unit;

raise when invariant is not held