Merge branch 'main' into doc-test-js-outuput

Author: aspeddro

CHANGELOG.md

@@ -3,6 +3,9 @@
 ## Next version
 
 - Added `assert_eq` function. https://github.com/rescript-association/rescript-core/pull/210
+- Add `RegExp.setLastIndex` function. https://github.com/rescript-association/rescript-core/pull/219
+- Add `Nullable.isNullable` function. https://github.com/rescript-association/rescript-core/pull/227
+- Remove some deps to Belt, Pervasives and Js. https://github.com/rescript-association/rescript-core/pull/226/commits
 
 ## 1.3.0
 

README.md

@@ -70,6 +70,12 @@ Open it so it's available in the global scope.
  }
 ```
 
+## ESM and CJS
+To use this library with CommonJS modules you should set the file extension in your project's `rescript.json` to `.res.js`, `.js`, `.res.cjs`, or `.cjs`. This will work with older versions of Node and most web projects using a bundler.
+
+To use this library with EcmaScript modules you should set the file extension in your project's `rescript.json` to `.res.mjs`, or `.mjs`.
+This will work with newer versions of Node and web projects using a modern bundler like Vite.
+
 ## What it looks like
 
 All relevant standard library modules are designed to be available directly in

src/Core__Array.mjs

@@ -1,6 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Js_math from "rescript/lib/es6/js_math.js";
 import * as Caml_option from "rescript/lib/es6/caml_option.js";
 
 function make(length, x) {
@@ -113,10 +112,14 @@ function swapUnsafe(xs, i, j) {
   xs[j] = tmp;
 }
 
+function random_int(min, max) {
+  return (Math.floor(Math.random() * (max - min | 0)) | 0) + min | 0;
+}
+
 function shuffle(xs) {
   var len = xs.length;
   for(var i = 0; i < len; ++i){
-    swapUnsafe(xs, i, Js_math.random_int(i, len));
+    swapUnsafe(xs, i, random_int(i, len));
   }
 }
 

src/Core__Array.res

@@ -203,10 +203,20 @@ let swapUnsafe = (xs, i, j) => {
   setUnsafe(xs, j, tmp)
 }
 
+module M = {
+  @val external floor: float => float = "Math.floor"
+  @val external random: unit => float = "Math.random"
+  external fromFloat: float => int = "%intoffloat"
+  external toFloat: int => float = "%identity"
+
+  let random_int: (int, int) => int = (min, max) =>
+    floor(random() *. toFloat(max - min))->fromFloat + min
+}
+
 let shuffle = xs => {
   let len = length(xs)
   for i in 0 to len - 1 {
-    swapUnsafe(xs, i, Js.Math.random_int(i, len)) /* [i,len) */
+    swapUnsafe(xs, i, M.random_int(i, len)) /* [i,len) */
   }
 }
 

src/Core__Int.mjs

@@ -1,7 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Core__Array from "./Core__Array.mjs";
-import * as PervasivesU from "rescript/lib/es6/pervasivesU.js";
 
 function equal(a, b) {
   return a === b;
@@ -26,6 +25,14 @@ function fromString(x, radix) {
   }
 }
 
+function abs(x) {
+  if (x >= 0) {
+    return x;
+  } else {
+    return -x | 0;
+  }
+}
+
 function range(start, end, optionsOpt) {
   var options = optionsOpt !== undefined ? optionsOpt : ({});
   var isInverted = start > end;
@@ -51,7 +58,7 @@ function range(start, end, optionsOpt) {
   } else {
     var range$1 = isInverted ? start - end | 0 : end - start | 0;
     var range$2 = options.inclusive === true ? range$1 + 1 | 0 : range$1;
-    length = Math.ceil(range$2 / PervasivesU.abs(step)) | 0;
+    length = Math.ceil(range$2 / abs(step)) | 0;
   }
   return Core__Array.fromInitializer(length, (function (i) {
                 return start + Math.imul(i, step) | 0;

src/Core__Int.res

@@ -48,6 +48,13 @@ external mod: (int, int) => int = "%modint"
 
 type rangeOptions = {step?: int, inclusive?: bool}
 
+let abs = x =>
+  if x >= 0 {
+    x
+  } else {
+    -x
+  }
+
 let range = (start, end, ~options: rangeOptions={}) => {
   let isInverted = start > end
 

src/Core__List.mjs

@@ -1,6 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
 import * as Caml_option from "rescript/lib/es6/caml_option.js";
 import * as Core__Array from "./Core__Array.mjs";
 
@@ -794,7 +793,12 @@ function reduceReverse(l, acc, f) {
   if (len < 1000) {
     return reduceReverseUnsafe(l, acc, f);
   } else {
-    return Belt_Array.reduceReverseU(toArray(l), acc, f);
+    var a = toArray(l);
+    var r = acc;
+    for(var i = a.length - 1 | 0; i >= 0; --i){
+      r = f(r, a[i]);
+    }
+    return r;
   }
 }
 
@@ -888,7 +892,14 @@ function reduceReverse2(l1, l2, acc, f) {
   if (len < 1000) {
     return reduceReverse2Unsafe(l1, l2, acc, f);
   } else {
-    return Belt_Array.reduceReverse2U(toArray(l1), toArray(l2), acc, f);
+    var a = toArray(l1);
+    var b = toArray(l2);
+    var r = acc;
+    var len$1 = a.length < b.length ? a.length : b.length;
+    for(var i = len$1 - 1 | 0; i >= 0; --i){
+      r = f(r, a[i], b[i]);
+    }
+    return r;
   }
 }
 

src/Core__List.res

@@ -63,12 +63,26 @@
 
 type t<'a> = list<'a>
 
-// TODO: This module should be inlined eventually, if we end up removing Belt
-// from the compiler.
 module A = {
-  let makeUninitializedUnsafe = Belt_Array.makeUninitializedUnsafe
-  let reduceReverseU = Belt_Array.reduceReverseU
-  let reduceReverse2U = Belt_Array.reduceReverse2U
+  @new external makeUninitializedUnsafe: int => array<'a> = "Array"
+  external min: ('a, 'a) => 'a = "%bs_min"
+
+  let reduceReverseU = (a, x, f) => {
+    let r = ref(x)
+    for i in Core__Array.length(a) - 1 downto 0 {
+      r.contents = f(r.contents, Core__Array.getUnsafe(a, i))
+    }
+    r.contents
+  }
+
+  let reduceReverse2U = (a, b, x, f) => {
+    let r = ref(x)
+    let len = min(Core__Array.length(a), Core__Array.length(b))
+    for i in len - 1 downto 0 {
+      r.contents = f(r.contents, Core__Array.getUnsafe(a, i), Core__Array.getUnsafe(b, i))
+    }
+    r.contents
+  }
 }
 
 external mutableCell: ('a, t<'a>) => t<'a> = "#makemutablelist"

src/Core__Nullable.res

@@ -7,6 +7,8 @@ external null: t<'a> = "#null"
 
 external undefined: t<'a> = "#undefined"
 
+external isNullable: t<'a> => bool = "#is_nullable"
+
 external make: 'a => t<'a> = "%identity"
 
 external toOption: t<'a> => option<'a> = "#nullable_to_opt"

src/Core__Nullable.resi

@@ -38,6 +38,27 @@ Console.log(undefined) // Logs `undefined` to the console.
 */
 external undefined: t<'a> = "#undefined"
 
+/**
+`isNullable(a)` returns `true` if `a` is null or undefined, `false` otherwise.
+
+## Examples
+
+```rescript
+let myStr = "Hello"
+let asNullable = myStr->Nullable.make
+
+// Can't do the below because we're now forced to check for nullability
+// myStr == asNullable
+
+// Check if asNullable is not null or undefined
+switch asNullable->Nullable.isNullable {
+| true => assert(false)
+| false => assert(true)
+}
+```
+*/
+external isNullable: t<'a> => bool = "#is_nullable"
+
 /**
 Creates a new nullable value from the provided value.
 This means the compiler will enforce null checks for the new value.

src/Core__RegExp.res

@@ -15,6 +15,7 @@ module Result = {
 @return(nullable) @send external exec: (t, string) => option<Result.t> = "exec"
 
 @get external lastIndex: t => int = "lastIndex"
+@set external setLastIndex: (t, int) => unit = "lastIndex"
 @get external ignoreCase: t => bool = "ignoreCase"
 @get external global: t => bool = "global"
 @get external multiline: t => bool = "multiline"

src/Core__RegExp.resi

@@ -170,6 +170,26 @@ Console.log(regexp->RegExp.lastIndex) // Logs `4` to the console
 @get
 external lastIndex: t => int = "lastIndex"
 
+/**
+`setLastIndex(regexp, index)` set the index the next match will start from.
+
+See [`RegExp.lastIndex`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/lastIndex) on MDN.
+
+## Examples
+```rescript
+// Match the first word in a sentence
+let regexp = RegExp.fromString("\\w+")
+let someStr = "Many words here."
+
+regexp->RegExp.setLastIndex(4)
+regexp->RegExp.exec(someStr)->ignore
+
+Console.log(regexp->RegExp.lastIndex) // Logs `10` to the console
+```
+*/
+@set
+external setLastIndex: (t, int) => unit = "lastIndex"
+
 /**
 `ignoreCase(regexp)` returns whether the ignore case (`i`) flag is set on this `RegExp`.
 

src/Core__String.res

@@ -13,6 +13,7 @@ let compare = (a: string, b: string) =>
 
 @get external length: string => int = "length"
 @get_index external get: (string, int) => option<string> = ""
+@get_index external getUnsafe: (string, int) => string = ""
 @send external charAt: (string, int) => string = "charAt"
 
 @send external charCodeAt: (string, int) => float = "charCodeAt"

src/Core__String.resi

@@ -150,6 +150,22 @@ String.get(`JS`, 4) == None
 @get_index
 external get: (string, int) => option<string> = ""
 
+/**
+`getUnsafe(str, index)` returns an `string` at the given `index` number.
+
+This is _unsafe_, meaning it will return `undefined` value if `index` does not exist in `string`.
+
+Use `String.getUnsafe` only when you are sure the `index` exists.
+## Examples
+
+```rescript
+String.getUnsafe("ReScript", 0) == "R"
+String.getUnsafe("Hello", 4) == "o"
+```
+*/
+@get_index
+external getUnsafe: (string, int) => string = ""
+
 /**
 `charAt(str, index)` gets the character at `index` within string `str`. If
 `index` is negative or greater than the length of `str`, it returns the empty