feat(stdlib): Implement isFloat, isInteger & isRational in Number module (#1393)

fix(compiler): Correctly handle underscores in bigint literals

Author: ospencer

compiler/src/utils/literals.re

@@ -138,13 +138,18 @@ let conv_bigint = s =>
       let accBits = ref(0);
       let results = ref([]);
       for (i in String.length(s) - 1 downto first) {
-        let digit = Int64.of_int(digit_value(s.[i]));
-        acc := Int64.logor(acc^, Int64.shift_left(digit, accBits^));
-        accBits := accBits^ + bits;
-        if (accBits^ >= 64) {
-          results := [acc^, ...results^];
-          accBits := accBits^ - 64;
-          acc := Int64.shift_right_logical(digit, bits - accBits^);
+        switch (s.[i]) {
+        | ('0' .. '9' | 'a' .. 'f' | 'A' .. 'F') as digit =>
+          let digit = Int64.of_int(digit_value(digit));
+          acc := Int64.logor(acc^, Int64.shift_left(digit, accBits^));
+          accBits := accBits^ + bits;
+          if (accBits^ >= 64) {
+            results := [acc^, ...results^];
+            accBits := accBits^ - 64;
+            acc := Int64.shift_right_logical(digit, bits - accBits^);
+          };
+        | '_' => ()
+        | _ => failwith("Impossible: Bad char")
         };
       };
       if (Int64.unsigned_compare(acc^, Int64.zero) > 0) {
@@ -171,21 +176,26 @@ let conv_bigint = s =>
       };
       let get_chunk = ((start_idx, end_idx)) => {
         let result = ref(Int64.zero);
+        let valid_digits = ref(0);
         for (i in start_idx to end_idx - 1) {
-          result :=
-            Int64.add(
-              Int64.mul(result^, Int64.of_int(base)),
-              Int64.of_int(digit_value(s.[i])),
-            );
+          let digit = s.[i];
+          if (digit != '_') {
+            incr(valid_digits);
+            result :=
+              Int64.add(
+                Int64.mul(result^, Int64.of_int(base)),
+                Int64.of_int(digit_value(s.[i])),
+              );
+          };
         };
-        result^;
+        (result^, valid_digits^);
       };
       // factor == 10l ** (places_at_a_time)
-      let factor =
+      let get_factor = num_digits =>
         List.fold_left(
           Int32.mul,
           Int32.one,
-          List.init(places_at_a_time, n => Int32.of_int(base)),
+          List.init(num_digits, n => Int32.of_int(base)),
         );
       let chunks =
         List.map(
@@ -194,10 +204,10 @@ let conv_bigint = s =>
         );
       let result =
         List.fold_left(
-          (acc, chunk) => {
+          (acc, (chunk, num_digits)) => {
             let ret =
               Mini_bigint.unsigned_add_i64(
-                Mini_bigint.unsigned_mul_i32(acc, factor),
+                Mini_bigint.unsigned_mul_i32(acc, get_factor(num_digits)),
                 chunk,
               );
             ret;

compiler/test/stdlib/number.test.gr

@@ -124,6 +124,30 @@ assert Number.neg(1/2) == -1/2
 assert Number.neg(BI.toNumber(1234t)) == BI.toNumber(-1234t)
 assert Number.neg(BI.toNumber(-1234t)) == BI.toNumber(1234t)
 
+// isFloat
+assert Number.isFloat(0.0)
+assert Number.isFloat(1.5)
+assert Number.isFloat(42.)
+assert Number.isFloat(9e6)
+assert Number.isFloat(0) == false
+assert Number.isFloat(10) == false
+assert Number.isFloat(2/3) == false
+
+// isInteger
+assert Number.isInteger(0)
+assert Number.isInteger(9)
+assert Number.isInteger(2_147_483_648)
+assert Number.isInteger(9_223_372_036_854_775_808)
+assert Number.isInteger(0.0) == false
+assert Number.isInteger(9e6) == false
+assert Number.isInteger(2/3) == false
+
+// isRational
+assert Number.isRational(1/2)
+assert Number.isRational(6/5)
+assert Number.isRational(1) == false
+assert Number.isRational(1.5) == false
+
 // isFinite
 assert Number.isFinite(0.0 / 0.0) == false // NaN
 assert Number.isFinite(1.0 / 0.0) == false // infinity

compiler/test/suites/numbers.re

@@ -41,6 +41,11 @@ describe("numbers", ({test, testSkip}) => {
   assertRun("number_syntax8", "print(1.2e2)", "120.0\n");
   assertRun("number_syntax9", "print(1l)", "1\n");
   assertRun("number_syntax10", "print(1L)", "1\n");
+  assertRun(
+    "number_syntax11",
+    "print(9_223_372_036_854_775_808)",
+    "9223372036854775808\n",
+  );
   assertRun(
     "number_shift_promote",
     "print(5 << 64)",

stdlib/number.gr

@@ -13,6 +13,8 @@ import {
   coerceNumberToWasmF64,
   reducedInteger,
   isFloat,
+  isInteger,
+  isRational,
   isBoxedNumber,
 } from "runtime/numbers"
 import { parseInt } from "runtime/stringUtils"
@@ -232,6 +234,45 @@ export let abs = (x: Number) => if (0 > x) x * -1 else x
  */
 export let neg = (x: Number) => x * -1
 
+/**
+ * Checks if a number is a floating point value.
+ *
+ * @param x: The number to check
+ * @returns `true` if the value is a floating point number or `false` otherwise
+ *
+ * @since v0.5.3
+ */
+@unsafe
+export let isFloat = (x: Number) => {
+  isFloat(WasmI32.fromGrain(x))
+}
+
+/**
+ * Checks if a number is an integer.
+ *
+ * @param x: The number to check
+ * @returns `true` if the value is an integer or `false` otherwise
+ *
+ * @since v0.5.3
+ */
+@unsafe
+export let isInteger = (x: Number) => {
+  isInteger(WasmI32.fromGrain(x))
+}
+
+/**
+ * Checks if a number is a non-integer rational value.
+ *
+ * @param x: The number to check
+ * @returns `true` if the value is a non-integer rational number or `false` otherwise
+ *
+ * @since v0.5.3
+ */
+@unsafe
+export let isRational = (x: Number) => {
+  isRational(WasmI32.fromGrain(x))
+}
+
 /**
  * Checks if a number is finite.
  * All values are finite exept for floating point NaN, infinity or negative infinity.

stdlib/number.md

@@ -425,6 +425,81 @@ Returns:
 |----|-----------|
 |`Number`|The negated operand|
 
+### Number.**isFloat**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+isFloat : Number -> Bool
+```
+
+Checks if a number is a floating point value.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`x`|`Number`|The number to check|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Bool`|`true` if the value is a floating point number or `false` otherwise|
+
+### Number.**isInteger**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+isInteger : Number -> Bool
+```
+
+Checks if a number is an integer.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`x`|`Number`|The number to check|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Bool`|`true` if the value is an integer or `false` otherwise|
+
+### Number.**isRational**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+isRational : Number -> Bool
+```
+
+Checks if a number is a non-integer rational value.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`x`|`Number`|The number to check|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Bool`|`true` if the value is a non-integer rational number or `false` otherwise|
+
 ### Number.**isFinite**
 
 <details disabled>

stdlib/runtime/numbers.gr

@@ -84,6 +84,28 @@ export let isFloat = x => {
   }
 }
 
+@unsafe
+export let isInteger = x => {
+  if (isBoxedNumber(x)) {
+    let tag = WasmI32.load(x, 4n)
+    WasmI32.eq(tag, Tags._GRAIN_INT32_BOXED_NUM_TAG) ||
+    WasmI32.eq(tag, Tags._GRAIN_INT64_BOXED_NUM_TAG) ||
+    WasmI32.eq(tag, Tags._GRAIN_BIGINT_BOXED_NUM_TAG)
+  } else {
+    true
+  }
+}
+
+@unsafe
+export let isRational = x => {
+  if (isBoxedNumber(x)) {
+    let tag = WasmI32.load(x, 4n)
+    WasmI32.eq(tag, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG)
+  } else {
+    false
+  }
+}
+
 @unsafe
 let isBigInt = x => {
   if (isBoxedNumber(x)) {

stdlib/runtime/numbers.md

@@ -10,6 +10,18 @@ isBoxedNumber : WasmI32 -> Bool
 isFloat : WasmI32 -> Bool
 ```
 
+### Numbers.**isInteger**
+
+```grain
+isInteger : WasmI32 -> Bool
+```
+
+### Numbers.**isRational**
+
+```grain
+isRational : WasmI32 -> Bool
+```
+
 ### Numbers.**isNumber**
 
 ```grain