Stricter number parsing (#8129)

* feat(stdlib/float): use number coercion instead of parseFloat in fromString

for stricter parsing

* chore(stdlib): enable experimental LetUnwrap feature

* feat(stdlib/int): use number coercion instead of parseInt in fromString

for stricter number parsing

* docs: update changelog

* add comment about number coercion

Author: glennsl

CHANGELOG.md

@@ -14,6 +14,8 @@
 
 #### :boom: Breaking Change
 
+- `Int.fromString` and `Float.fromString` use stricter number parsing and no longer uses an explicit radix argument, but instead supports parsing hexadecimal, binary and exponential notation.
+
 #### :eyeglasses: Spec Compliance
 
 #### :rocket: New Feature

packages/@rescript/runtime/Stdlib_Float.res

@@ -58,11 +58,11 @@ external toPrecisionWithPrecision: (float, ~digits: int) => string = "toPrecisio
 external toStringWithRadix: (float, ~radix: int) => string = "toString"
 @send external toLocaleString: float => string = "toLocaleString"
 
-let fromString = i =>
-  switch parseFloat(i) {
-  | i if isNaN(i) => None
-  | i => Some(i)
-  }
+let fromString: string => option<float> = %raw(`str => {
+  if (!str || !str.trim()) return;
+  let num = +str; // Number coercion, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number#number_coercion
+  return isNaN(num) ? undefined : num;
+}`)
 
 external toInt: float => int = "%intoffloat"
 external fromInt: int => float = "%identity"

packages/@rescript/runtime/Stdlib_Int.res

@@ -45,20 +45,9 @@ external toStringWithRadix: (int, ~radix: int) => string = "toString"
 external toFloat: int => float = "%identity"
 external fromFloat: float => int = "%intoffloat"
 
-let fromString = (x, ~radix=?) => {
-  let maybeInt = switch radix {
-  | Some(radix) => Stdlib_Float.parseInt(x, ~radix)
-  | None => Stdlib_Float.parseInt(x)
-  }
-
-  if Stdlib_Float.isNaN(maybeInt) {
-    None
-  } else if maybeInt > Constants.maxValue->toFloat || maybeInt < Constants.minValue->toFloat {
-    None
-  } else {
-    let asInt = fromFloat(maybeInt)
-    Some(asInt)
-  }
+let fromString: string => option<int> = str => {
+  let? Some(num) = str->Stdlib_Float.fromString
+  num === num->fromFloat->toFloat && Stdlib_Float.isFinite(num) ? Some(num->fromFloat) : None
 }
 
 external mod: (int, int) => int = "%modint"

packages/@rescript/runtime/Stdlib_Int.resi

@@ -295,18 +295,20 @@ Int.fromFloat(0.9999) == 0
 external fromFloat: float => int = "%intoffloat"
 
 /**
-`fromString(str, ~radix=?)` return an `option<int>` representing the given value
-`str`. `~radix` specifies the radix base to use for the formatted number.
+`fromString(str)` return an `option<int>` representing the given value
+`str`. Hexadecimal, binary and exponential notation is supported.
 
 ## Examples
 
 ```rescript
 Int.fromString("0") == Some(0)
+Int.fromString("0x6") == Some(6)
+Int.fromString("2.5e2") == Some(250)
 Int.fromString("NaN") == None
-Int.fromString("6", ~radix=2) == None
+Int.fromString("0b6") == None
 ```
 */
-let fromString: (string, ~radix: int=?) => option<int>
+let fromString: string => option<int>
 
 /**
 `mod(n1, n2)` calculates the modulo (remainder after division) of two integers.

packages/@rescript/runtime/lib/es6/Stdlib_Float.js

@@ -3,14 +3,11 @@
 
 let Constants = {};
 
-function fromString(i) {
-  let i$1 = parseFloat(i);
-  if (Number.isNaN(i$1)) {
-    return;
-  } else {
-    return i$1;
-  }
-}
+let fromString = (str => {
+  if (!str || !str.trim()) return;
+  let num = +str; // Number coercion, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number#number_coercion
+  return isNaN(num) ? undefined : num;
+});
 
 function clamp(min, max, value) {
   let value$1 = max !== undefined && max < value ? max : value;

packages/@rescript/runtime/lib/es6/Stdlib_Int.js

@@ -1,13 +1,18 @@
 
 
 import * as Stdlib_Array from "./Stdlib_Array.js";
+import * as Stdlib_Float from "./Stdlib_Float.js";
 
-function fromString(x, radix) {
-  let maybeInt = radix !== undefined ? parseInt(x, radix) : parseInt(x);
-  if (Number.isNaN(maybeInt) || maybeInt > 2147483647 || maybeInt < -2147483648) {
-    return;
+function fromString(str) {
+  let num = Stdlib_Float.fromString(str);
+  if (num !== undefined) {
+    if (num === (num | 0) && isFinite(num)) {
+      return num | 0;
+    } else {
+      return;
+    }
   } else {
-    return maybeInt | 0;
+    return num;
   }
 }
 

packages/@rescript/runtime/lib/js/Stdlib_Float.js

@@ -3,14 +3,11 @@
 
 let Constants = {};
 
-function fromString(i) {
-  let i$1 = parseFloat(i);
-  if (Number.isNaN(i$1)) {
-    return;
-  } else {
-    return i$1;
-  }
-}
+let fromString = (str => {
+  if (!str || !str.trim()) return;
+  let num = +str; // Number coercion, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number#number_coercion
+  return isNaN(num) ? undefined : num;
+});
 
 function clamp(min, max, value) {
   let value$1 = max !== undefined && max < value ? max : value;

packages/@rescript/runtime/lib/js/Stdlib_Int.js

@@ -1,13 +1,18 @@
 'use strict';
 
 let Stdlib_Array = require("./Stdlib_Array.js");
+let Stdlib_Float = require("./Stdlib_Float.js");
 
-function fromString(x, radix) {
-  let maybeInt = radix !== undefined ? parseInt(x, radix) : parseInt(x);
-  if (Number.isNaN(maybeInt) || maybeInt > 2147483647 || maybeInt < -2147483648) {
-    return;
+function fromString(str) {
+  let num = Stdlib_Float.fromString(str);
+  if (num !== undefined) {
+    if (num === (num | 0) && isFinite(num)) {
+      return num | 0;
+    } else {
+      return;
+    }
   } else {
-    return maybeInt | 0;
+    return num;
   }
 }
 

packages/@rescript/runtime/rescript.json

@@ -1,5 +1,8 @@
 {
   "name": "@rescript/runtime",
+  "experimental-features": {
+    "LetUnwrap": true
+  },
   "sources": [
     {
       "dir": "."