Int

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

add

RESCRIPT

let add: (t, value) => unit

addCheck

RESCRIPT

let addCheck: (t, value) => bool

checkInvariantInternal

RESCRIPT

let checkInvariantInternal: t => unit

throw when invariant is not held

cmp

RESCRIPT

let cmp: (t, t) => int

copy

RESCRIPT

let copy: t => t

diff

RESCRIPT

let diff: (t, t) => t

eq

RESCRIPT

let eq: (t, t) => bool

every

RESCRIPT

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

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

everyU

Deprecated

Use every instead

RESCRIPT

let everyU: (t, value => bool) => bool

forEach

RESCRIPT

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

In increasing order

forEachU

Deprecated

Use forEach instead

RESCRIPT

let forEachU: (t, value => unit) => unit

fromArray

RESCRIPT

let fromArray: array<value> => t

fromSortedArrayUnsafe

RESCRIPT

let fromSortedArrayUnsafe: array<value> => t

get

RESCRIPT

let get: (t, value) => option<value>

getExn

RESCRIPT

let getExn: (t, value) => value

getOrThrow

RESCRIPT

let getOrThrow: (t, value) => value

getUndefined

RESCRIPT

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

has

RESCRIPT

let has: (t, value) => bool

intersect

RESCRIPT

let intersect: (t, t) => t

isEmpty

RESCRIPT

let isEmpty: t => bool

keep

RESCRIPT

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.

keepU

Deprecated

Use keep instead

RESCRIPT

let keepU: (t, value => bool) => t

make

RESCRIPT

let make: unit => t

maximum

RESCRIPT

let maximum: t => option<value>

maxUndefined

RESCRIPT

let maxUndefined: t => Js.undefined<value>

mergeMany

RESCRIPT

let mergeMany: (t, array<value>) => unit

minimum

RESCRIPT

let minimum: t => option<value>

minUndefined

RESCRIPT

let minUndefined: t => Js.undefined<value>

partition

RESCRIPT

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.

partitionU

Deprecated

Use partition instead

RESCRIPT

let partitionU: (t, value => bool) => (t, t)

reduce

RESCRIPT

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

Iterate in increasing order.

reduceU

Deprecated

Use reduce instead

RESCRIPT

let reduceU: (t, 'a, ('a, value) => 'a) => 'a

remove

RESCRIPT

let remove: (t, value) => unit

removeCheck

RESCRIPT

let removeCheck: (t, value) => bool

removeMany

RESCRIPT

let removeMany: (t, array<value>) => unit

size

RESCRIPT

let size: t => int

some

RESCRIPT

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

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

someU

Deprecated

Use some instead

RESCRIPT

let someU: (t, value => bool) => bool

split

RESCRIPT

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

split(s, key) return a fresh copy of each

subset

RESCRIPT

let subset: (t, t) => bool

t

RESCRIPT

type t

The type of sets.

toArray

RESCRIPT

let toArray: t => array<value>

In increasing order with respect

toList

RESCRIPT

let toList: t => list<value>

In increasing order with respect

union

RESCRIPT

let union: (t, t) => t

value

RESCRIPT

type value = int

The type of the set elements.