@rescript/std/lib/es6/sort.js

The motiviation of this repo is that when ReScript users want to share their library with JS users, the JS users don't need have ReScript toolchain installed, this makes sharing code with JS users easier (more details on that topic can be found in our [Ex

import * as Curry from "./curry.js";

function merge(order, l1, l2) {
  if (!l1) {
    return l2;
  }
  if (!l2) {
    return l1;
  }
  var h2 = l2.hd;
  var h1 = l1.hd;
  if (Curry._2(order, h1, h2)) {
    return {
            hd: h1,
            tl: merge(order, l1.tl, l2)
          };
  } else {
    return {
            hd: h2,
            tl: merge(order, l1, l2.tl)
          };
  }
}

function list(order, l) {
  var initlist = function (param) {
    if (!param) {
      return /* [] */0;
    }
    var match = param.tl;
    var e = param.hd;
    if (!match) {
      return {
              hd: {
                hd: e,
                tl: /* [] */0
              },
              tl: /* [] */0
            };
    }
    var e2 = match.hd;
    return {
            hd: Curry._2(order, e, e2) ? ({
                  hd: e,
                  tl: {
                    hd: e2,
                    tl: /* [] */0
                  }
                }) : ({
                  hd: e2,
                  tl: {
                    hd: e,
                    tl: /* [] */0
                  }
                }),
            tl: initlist(match.tl)
          };
  };
  var merge2 = function (param) {
    if (!param) {
      return param;
    }
    var match = param.tl;
    if (match) {
      return {
              hd: merge(order, param.hd, match.hd),
              tl: merge2(match.tl)
            };
    } else {
      return param;
    }
  };
  var _param = initlist(l);
  while(true) {
    var param = _param;
    if (!param) {
      return /* [] */0;
    }
    if (!param.tl) {
      return param.hd;
    }
    _param = merge2(param);
    continue ;
  };
}

function swap(arr, i, j) {
  var tmp = arr[i];
  arr[i] = arr[j];
  arr[j] = tmp;
}

function array(cmp, arr) {
  var qsort = function (_lo, _hi) {
    while(true) {
      var hi = _hi;
      var lo = _lo;
      if ((hi - lo | 0) < 6) {
        return ;
      }
      var mid = ((lo + hi | 0) >>> 1);
      if (Curry._2(cmp, arr[mid], arr[lo])) {
        swap(arr, mid, lo);
      }
      if (Curry._2(cmp, arr[hi], arr[mid])) {
        swap(arr, mid, hi);
        if (Curry._2(cmp, arr[mid], arr[lo])) {
          swap(arr, mid, lo);
        }
        
      }
      var pivot = arr[mid];
      var i = lo + 1 | 0;
      var j = hi - 1 | 0;
      if (!Curry._2(cmp, pivot, arr[hi]) || !Curry._2(cmp, arr[lo], pivot)) {
        throw {
              RE_EXN_ID: "Invalid_argument",
              _1: "Sort.array",
              Error: new Error()
            };
      }
      while(i < j) {
        while(!Curry._2(cmp, pivot, arr[i])) {
          i = i + 1 | 0;
        };
        while(!Curry._2(cmp, arr[j], pivot)) {
          j = j - 1 | 0;
        };
        if (i < j) {
          swap(arr, i, j);
        }
        i = i + 1 | 0;
        j = j - 1 | 0;
      };
      if ((j - lo | 0) <= (hi - i | 0)) {
        qsort(lo, j);
        _lo = i;
        continue ;
      }
      qsort(i, hi);
      _hi = j;
      continue ;
    };
  };
  qsort(0, arr.length - 1 | 0);
  for(var i = 1 ,i_finish = arr.length; i < i_finish; ++i){
    var val_i = arr[i];
    if (!Curry._2(cmp, arr[i - 1 | 0], val_i)) {
      arr[i] = arr[i - 1 | 0];
      var j = i - 1 | 0;
      while(j >= 1 && !Curry._2(cmp, arr[j - 1 | 0], val_i)) {
        arr[j] = arr[j - 1 | 0];
        j = j - 1 | 0;
      };
      arr[j] = val_i;
    }
    
  }
}

export {
  list ,
  array ,
  merge ,
}
/* No side effect */