SortArray

SortArrayInt

RES
module Int = Belt.SortArray.Int

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

SortArrayString

RES
module String = Belt.SortArray.String

Specialized when key type is string, more efficient than the generic type

strictlySortedLengthU

RES
let strictlySortedLengthU: (array<'a>, (. 'a, 'a) => bool) => int

strictlySortedLength

RES
let strictlySortedLength: (array<'a>, ('a, 'a) => bool) => int

strictlySortedLenght(xs, cmp); return +n means increasing order -n means negative order

RES
Belt.SortArray.strictlySortedLength([1, 2, 3, 4, 3], (x, y) => x < y) == 4

Belt.SortArray.strictlySortedLength([], (x, y) => x < y) == 0

Belt.SortArray.strictlySortedLength([1], (x, y) => x < y) == 1

Belt.SortArray.strictlySortedLength([4, 3, 2, 1], (x, y) => x < y) == -4

isSortedU

RES
let isSortedU: (array<'a>, (. 'a, 'a) => int) => bool

isSorted

RES
let isSorted: (array<'a>, ('a, 'a) => int) => bool

isSorted(arr, cmp): Returns true if array is increasingly sorted (equal is okay)

stableSortInPlaceByU

RES
let stableSortInPlaceByU: (array<'a>, (. 'a, 'a) => int) => unit

stableSortInPlaceBy

RES
let stableSortInPlaceBy: (array<'a>, ('a, 'a) => int) => unit

stableSortByU

RES
let stableSortByU: (array<'a>, (. 'a, 'a) => int) => array<'a>

stableSortBy

RES
let stableSortBy: (array<'a>, ('a, 'a) => int) => array<'a>

stableSortBy(xs, cmp): Returns a fresh array Sort xs in place using comparator cmp, the stable means if the elements are equal, their order will be preserved

binarySearchByU

RES
let binarySearchByU: (array<'a>, 'a, (. 'a, 'a) => int) => int

binarySearchBy

RES
let binarySearchBy: (array<'a>, 'a, ('a, 'a) => int) => 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 lnot(-1) == 0 since lnot(- (len + 1)) == len

RES
Belt.SortArray.binarySearchBy([1, 2, 3, 4, 33, 35, 36], 33, Pervasives.compare) == 4

lnot(Belt.SortArray.binarySearchBy([1, 3, 5, 7], 4, Pervasives.compare)) == 2