feat(stdlib): Add parse function to Number module (#1517)

fix(runtime): Properly divide bigints in the number type
chore(stdlib): Format runtime

Author: ospencer

compiler/test/stdlib/number.test.gr

@@ -77,6 +77,7 @@ assert Number.isNaN(Number.mul(Number.nan, Number.nan))
 assert Number.div(25, 5) == 5
 assert Number.div(9223372036854775809, 9) == 1024819115206086201
 assert Number.div(9223372036854775809, 9223372036854775809) == 1
+assert Number.div(9223372036854775808, 27670116110564327424) == 1/3
 assert Number.div(Number.infinity, 10) == Number.infinity
 assert Number.isNaN(Number.div(Number.infinity, Number.infinity))
 assert Number.isNaN(Number.div(Number.infinity, Number.nan))
@@ -606,6 +607,24 @@ assert Result.isErr(Number.parseInt("zzzzz", 9223372036854775807))
 assert Result.isErr(Number.parseInt("10", 1.23))
 assert Result.isErr(Number.parseInt("10", 2/3))
 
+// Number.parse
+// These tests primarily focus on rational parsing
+assert Number.parse("") == Err("Invalid input")
+assert Number.parse("42") == Ok(42)
+assert Number.parse("123.45") == Ok(123.45)
+assert Number.parse("1/1") == Ok(1)
+assert Number.parse("1/3") == Ok(1/3)
+assert Number.parse("9/3") == Ok(3)
+assert Number.parse("3/9") == Ok(1/3)
+assert Number.parse("-3/9") == Ok(-1/3)
+assert Number.parse("-3/-9") == Ok(1/3)
+assert Number.parse("0x3/-9") == Ok(-1/3)
+assert Number.parse("3/-0x9") == Ok(-1/3)
+assert Number.parse("9223372036854775808/27_670_116_110_564_327_424") == Ok(1/3)
+assert Number.parse("1/2/") == Err("Invalid digit in input")
+assert Number.parse("1/") == Err("Invalid input")
+assert Number.parse("1//") == Err("Invalid digit in input")
+
 // Number.sign
 assert Number.sign(-10000) == -1
 assert Number.sign(22222) == 1

stdlib/number.gr

@@ -20,7 +20,7 @@ import {
 } from "runtime/numbers"
 import Atoi from "runtime/atoi/parse"
 import Atof from "runtime/atof/parse"
-import { newFloat64, newInt64 } from "runtime/dataStructures"
+import { newFloat64, newInt64, allocateString } from "runtime/dataStructures"
 import Tags from "runtime/unsafe/tags"
 import Exception from "runtime/exception"
 
@@ -904,6 +904,68 @@ export let parseInt = Atoi.parseInt
  */
 export let parseFloat = Atof.parseFloat
 
+/**
+ * Parses a string representation of an integer, float, or rational into a `Number`.
+ * Underscores that appear in the numeric portion of the input are ignored.
+ *
+ * @param input: The string to parse
+ * @returns `Ok(value)` containing the parsed number on a successful parse or `Err(msg)` containing an error message string otherwise
+ *
+ * @since v0.5.5
+ */
+@unsafe
+export let parse = input => {
+  match (parseInt(input, 10)) {
+    Ok(number) => Ok(number),
+    Err(msg) =>
+      match (parseFloat(input)) {
+        Ok(number) => Ok(number),
+        Err(_) => {
+          // Split the input on a `/` and attempt to parse a rational
+          let (+) = WasmI32.add
+          let (-) = WasmI32.sub
+          let (<) = WasmI32.ltU
+          let (==) = WasmI32.eq
+
+          // Search for `/`
+          let input = WasmI32.fromGrain(input)
+          let len = WasmI32.load(input, 4n)
+          let mut slashIdx = -1n
+          for (let mut i = 0n; i < len; i += 1n) {
+            if (WasmI32.load8U(input + i, 8n) == 0x2fn) {
+              slashIdx = i
+              break
+            }
+          }
+
+          if (slashIdx == -1n) {
+            Err(msg)
+          } else {
+            let numeratorLen = slashIdx
+            let denominatorLen = len - slashIdx - 1n
+
+            let numerator = allocateString(numeratorLen)
+            Memory.copy(numerator + 8n, input + 8n, numeratorLen)
+            let numerator = WasmI32.toGrain(numerator): String
+
+            let denominator = allocateString(denominatorLen)
+            Memory.copy(
+              denominator + 8n,
+              input + 8n + slashIdx + 1n,
+              denominatorLen
+            )
+            let denominator = WasmI32.toGrain(denominator): String
+
+            match ((parseInt(numerator, 10), parseInt(denominator, 10))) {
+              (Ok(numerator), Ok(denominator)) => Ok(numerator / denominator),
+              (Err(msg), _) | (_, Err(msg)) => Err(msg),
+            }
+          }
+        },
+      },
+  }
+}
+
 /**
  * Computes how many times pi has to be subtracted to achieve the required bounds for sin.
  */

stdlib/number.md

@@ -755,6 +755,32 @@ Returns:
 |----|-----------|
 |`Result<Number, String>`|`Ok(value)` containing the parsed number on a successful parse or `Err(msg)` containing an error message string otherwise|
 
+### Number.**parse**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+parse : String -> Result<Number, String>
+```
+
+Parses a string representation of an integer, float, or rational into a `Number`.
+Underscores that appear in the numeric portion of the input are ignored.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`input`|`String`|The string to parse|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Result<Number, String>`|`Ok(value)` containing the parsed number on a successful parse or `Err(msg)` containing an error message string otherwise|
+
 ### Number.**sin**
 
 <details>

stdlib/runtime/atof/common.gr

@@ -152,7 +152,7 @@ export let power = (q: WasmI32) => {
   let (*) = WasmI32.mul
   let (>>) = WasmI32.shrS
 
-  (q * (152_170n + 65536n) >> 16n) + 63n
+  ((q * (152_170n + 65536n)) >> 16n) + 63n
 }
 
 @unsafe

stdlib/runtime/atof/parse.gr

@@ -82,7 +82,7 @@ let parse8Digits = (digits: WasmI64) => {
   let c = (b & _MASK) * 0x000F_4240_0000_0064N
   let d = (b >> 16N & _MASK) * 0x0000_2710_0000_0001N
 
-  c + d >> 32N
+  (c + d) >> 32N
 }
 
 @unsafe

stdlib/runtime/numbers.gr

@@ -1426,7 +1426,7 @@ let numberTimesDivideBigIntHelp = (x, y, isDivide) => {
       },
       t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
         if (isDivide) {
-          reducedBigInteger(BI.div(x, y))
+          reducedFractionBigInt(x, y)
         } else {
           reducedBigInteger(BI.mul(x, y))
         }