Subclassing built-in JavaScript (objects such as Array) in TypeScript

binary-search.ts

/**
 * Returns the index of the searched element. Returns -1 when no element is found.
 */
function binarySearch<T>(array: SortedArray<T>, item: T): number {
  let [left, right] = [0, array.length - 1];

  while (left <= right) {
    let middle = Math.floor((left + right) / 2);

    if (array[middle] === item) {
      return middle;
    }

    if (array[middle] < item) {
      left = middle + 1;
    } else {
      right = middle -1
    }
  }

  return -1;
}

SortedArray.ts

type Comparator<T> = (left: T, right: T) => Comparison;

enum Comparison {
  LessThan = -1,
  Equal = 0,
  GreaterThan = 1,
}

/**
 * We can't allow sorted arrays to be mutated (e.g. pushed to).
 */
interface SortedArray<T> extends ReadonlyArray<T> {
  readonly brand: unique symbol;
}

interface SortedArrayConstructor {
  new <T>(items: T[], comparator: Comparator<T>): SortedArray<T>;
}

const SortedArray: SortedArrayConstructor = class<T> extends Array<T> {
  constructor(items: T[], comparator: Comparator<T>) {
    super(...items.slice().sort(comparator));
  }
}

Usage:

const comparator: Comparator<number> = (left, right) => {
  if (left === right) {
    return Comparison.Equal;
  } else if (left < right) {
    return Comparison.LessThan
  } else {
    return Comparison.GreaterThan
  }
}

binarySearch(new SortedArray([5, 1, 4, 9, Math.E], comparator), 4); 
binarySearch([5, 1, 4, 9, Math.E], 4); // ⛔️ Compile-time error (array is not a SortedArray)