Belt.SortArray.Int

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

element

RESCRIPT
type element = int

strictlySortedLength

RESCRIPT
let strictlySortedLength: array<element> => int

The same as [`Belt_SortArray.strictlySortedLength`]() except the comparator is fixed **return** `+n` means increasing order `-n` means negative order

isSorted

RESCRIPT
let isSorted: array<element> => bool

`sorted xs` return true if `xs` is in non strict increasing order

stableSortInPlace

RESCRIPT
let stableSortInPlace: array<element> => unit

The same as [`Belt_SortArray.stableSortInPlaceBy`]() except the comparator is fixed

stableSort

RESCRIPT
let stableSort: array<element> => array<element>

The same as [`Belt_SortArray.stableSortBy`]() except the comparator is fixed

binarySearch

RESCRIPT
let binarySearch: (array<element>, element) => int

If value is not found and value is less than one or more elements in array, the negative number returned is the bitwise complement of the index of the first element that is larger than value. If value is not found and value is greater than all elements in array, the negative number returned is the bitwise complement of (the index of the last element plus 1) for example, if `key` is smaller than all elements return `-1` since `lnot (-1) = 0` if `key` is larger than all elements return `- (len + 1)` since `lnot (-(len+1)) = len`

union

RESCRIPT
let union: (array<element>, int, int, array<element>, int, int, array<element>, int) => int

`union src src1ofs src1len src2 src2ofs src2len dst dstofs cmp` assume `src` and `src2` is strictly sorted. for equivalent elements, it is picked from `src` also assume that `dst` is large enough to store all elements

intersect

RESCRIPT
let intersect: (array<element>, int, int, array<element>, int, int, array<element>, int) => int

diff

RESCRIPT
let diff: (array<element>, int, int, array<element>, int, int, array<element>, int) => int