@grain/stdlib 0.4.1 → 0.4.5

package/runtime/string.gr

@@ -14,7 +14,7 @@ import WasmI32, {
   geS as (>=),
   gtS as (>),
   leS as (<=),
-  ltS as (<)
+  ltS as (<),
 } from "runtime/unsafe/wasmi32"
 import WasmI64 from "runtime/unsafe/wasmi64"
 import WasmF32 from "runtime/unsafe/wasmf32"
@@ -25,29 +25,39 @@ import NumberUtils from "runtime/numberUtils"
 
 import { allocateString, allocateArray } from "runtime/dataStructures"
 
-import foreign wasm fd_write: (WasmI32, WasmI32, WasmI32, WasmI32) -> WasmI32 from "wasi_snapshot_preview1"
+import foreign wasm fd_write: (
+  WasmI32,
+  WasmI32,
+  WasmI32,
+  WasmI32,
+) -> WasmI32 from "wasi_snapshot_preview1"
 
-primitive (!) : Bool -> Bool = "@not"
-primitive (&&) : (Bool, Bool) -> Bool = "@and"
-primitive (||) : (Bool, Bool) -> Bool = "@or"
+primitive (!): Bool -> Bool = "@not"
+primitive (&&): (Bool, Bool) -> Bool = "@and"
+primitive (||): (Bool, Bool) -> Bool = "@or"
 
-enum StringList { SLEmpty, SLCons(String, StringList) }
+enum StringList {
+  SLEmpty,
+  SLCons(String, StringList),
+}
 
 @disableGC
 let slConsDisableGc = (a, b) => {
   Memory.incRef(WasmI32.fromGrain(SLCons))
+  Memory.incRef(WasmI32.fromGrain(a))
+  // for easier chaining, we don't incRef `b`
   SLCons(a, b)
 }
 
 @disableGC
-let mut _RUNTIME_TYPE_METADATA_PTR = 0x01n;
+let mut _RUNTIME_TYPE_METADATA_PTR = 0x01n
 
 @disableGC
 let initPtr = () => {
   // hack to avoid incRef on this pointer
   _RUNTIME_TYPE_METADATA_PTR = 0x408n
 }
-initPtr();
+initPtr()
 
 @disableGC
 let findTypeMetadata = (moduleId, typeId) => {
@@ -80,7 +90,7 @@ let findTypeMetadata = (moduleId, typeId) => {
 }
 
 @disableGC
-let getVariantName = (variant) => {
+let getVariantName = variant => {
   let moduleId = WasmI32.load(variant, 4n) >> 1n
   let typeId = WasmI32.load(variant, 8n) >> 1n
   let variantId = WasmI32.load(variant, 12n) >> 1n
@@ -111,7 +121,7 @@ let getVariantName = (variant) => {
 }
 
 @disableGC
-let getRecordFieldNames = (record_) => {
+let getRecordFieldNames = record_ => {
   let moduleId = WasmI32.load(record_, 4n) >> 1n
   let typeId = WasmI32.load(record_, 8n) >> 1n
   let arity = WasmI32.load(record_, 12n)
@@ -130,7 +140,7 @@ let getRecordFieldNames = (record_) => {
       let fieldLength = WasmI32.load(fields + fieldOffset, 4n)
       let fieldName = allocateString(fieldLength)
       Memory.copy(fieldName + 8n, fields + fieldOffset + 8n, fieldLength)
-      WasmI32.store(fieldArray + (i * 4n), fieldName, 8n)
+      WasmI32.store(fieldArray + i * 4n, fieldName, 8n)
 
       fieldOffset += WasmI32.load(fields + fieldOffset, 0n)
     }
@@ -142,8 +152,9 @@ let getRecordFieldNames = (record_) => {
 @disableGC
 let rec totalBytes = (acc, list) => {
   match (list) {
-    SLCons(hd, tl) => totalBytes(acc + WasmI32.load(WasmI32.fromGrain(hd), 4n), tl),
-    SLEmpty => acc
+    SLCons(hd, tl) =>
+      totalBytes(acc + WasmI32.load(WasmI32.fromGrain(hd), 4n), tl),
+    SLEmpty => acc,
   }
 }
 
@@ -156,25 +167,28 @@ let rec writeStrings = (buf, list) => {
       Memory.copy(buf, hd + 8n, hdSize)
       writeStrings(buf + hdSize, tl)
     },
-    SLEmpty => void
+    SLEmpty => void,
   }
 }
 
 @disableGC
-let join = (list) => {
+let join = list => {
   let len = totalBytes(0n, list)
   let str = allocateString(len)
   writeStrings(str + 8n, list)
   WasmI32.toGrain(str): String
 }
 
-let reverse = (list) => {
+@disableGC
+let reverse = list => {
+  @disableGC
   let rec iter = (list, acc) => {
     match (list) {
       SLEmpty => acc,
-      SLCons(first, rest) => iter(rest, SLCons(first, acc))
+      SLCons(first, rest) => iter(rest, slConsDisableGc(first, acc)),
     }
   }
+  Memory.incRef(WasmI32.fromGrain(SLEmpty))
   iter(list, SLEmpty)
 }
 
@@ -235,7 +249,12 @@ let escape = (ptr, isString) => {
   let mut newSize = 2n // extra space for quote characters
   for (let mut i = 0n; i < size; i += 1n) {
     let byte = WasmI32.load8U(ptr + i, startOffset)
-    if (byte >= _SEQ_B && byte <= _SEQ_R /* b, f, n, r, t, v */ || byte == _SEQ_V || byte == _SEQ_SLASH || byte == _SEQ_QUOTE) {
+    if (
+      byte >= _SEQ_B && byte <= _SEQ_R || /* b, f, n, r, t, v */
+      byte == _SEQ_V ||
+      byte == _SEQ_SLASH ||
+      byte == _SEQ_QUOTE
+    ) {
       newSize += 2n
     } else {
       newSize += 1n
@@ -249,7 +268,12 @@ let escape = (ptr, isString) => {
 
   for (let mut i = 0n; i < size; i += 1n) {
     let byte = WasmI32.load8U(ptr + i, startOffset)
-    if (byte >= _SEQ_B && byte <= _SEQ_R /* b, f, n, r, t, v */ || byte == _SEQ_V || byte == _SEQ_SLASH || byte == _SEQ_QUOTE) {
+    if (
+      byte >= _SEQ_B && byte <= _SEQ_R || /* b, f, n, r, t, v */
+      byte == _SEQ_V ||
+      byte == _SEQ_SLASH ||
+      byte == _SEQ_QUOTE
+    ) {
       WasmI32.store8(escapedString + j, _SEQ_SLASH, stringOffset)
       j += 1n
       let seq = match (byte) {
@@ -259,7 +283,7 @@ let escape = (ptr, isString) => {
         r when r == _SEQ_R => 0x72n,
         t when t == _SEQ_T => 0x74n,
         v when v == _SEQ_V => 0x76n,
-        _ => byte
+        _ => byte,
       }
       WasmI32.store8(escapedString + j, seq, stringOffset)
       j += 1n
@@ -381,19 +405,31 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
             variantName
           } else {
             let comspace = ", "
+            let rparen = ")"
             Memory.incRef(WasmI32.fromGrain(SLEmpty))
-            let mut strings = slConsDisableGc(")", SLEmpty)
+            let mut strings = slConsDisableGc(rparen, SLEmpty)
             for (let mut i = variantArity * 4n - 4n; i >= 0n; i -= 4n) {
-              let tmp = toStringHelp(WasmI32.load(ptr + i, 20n), extraIndents, false)
+              let tmp = toStringHelp(
+                WasmI32.load(ptr + i, 20n),
+                extraIndents,
+                false
+              )
               strings = slConsDisableGc(tmp, strings)
+              Memory.decRef(WasmI32.fromGrain(tmp))
               if (i > 0n) {
-                Memory.incRef(WasmI32.fromGrain(comspace))
                 strings = slConsDisableGc(comspace, strings)
               }
             }
             Memory.incRef(WasmI32.fromGrain(variantName))
-            strings = slConsDisableGc(variantName, slConsDisableGc("(", strings))
+            let lparen = "("
+            strings = slConsDisableGc(
+              variantName,
+              slConsDisableGc(lparen, strings)
+            )
             let string = join(strings)
+            Memory.decRef(WasmI32.fromGrain(variantName))
+            Memory.decRef(WasmI32.fromGrain(lparen))
+            Memory.decRef(WasmI32.fromGrain(rparen))
             Memory.decRef(WasmI32.fromGrain(strings))
             Memory.decRef(WasmI32.fromGrain(comspace))
             string
@@ -408,38 +444,60 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
         "<record value>"
       } else {
         let prevPadAmount = extraIndents * 2n
-        let prevSpacePadding = if (prevPadAmount == 0n) "" else {
+        let prevSpacePadding = if (prevPadAmount == 0n) {
+          ""
+        } else {
           let v = allocateString(prevPadAmount)
-          Memory.fill(v + 8n, 0x20n, prevPadAmount) // create indentation for closing brace
-          WasmI32.toGrain(v) : String
+          Memory.fill(
+            v + 8n,
+            0x20n,
+            prevPadAmount
+          ) // create indentation for closing brace
+          WasmI32.toGrain(v): String
         }
         let padAmount = (extraIndents + 1n) * 2n
         let spacePadding = allocateString(padAmount)
         Memory.fill(spacePadding + 8n, 0x20n, padAmount) // create indentation
         let spacePadding = WasmI32.toGrain(spacePadding): String
         Memory.incRef(WasmI32.fromGrain(SLEmpty))
-        let mut strings = slConsDisableGc("\n", slConsDisableGc(prevSpacePadding, slConsDisableGc("}", SLEmpty)))
+        let newline = "\n"
+        let rbrace = "}"
+        let mut strings = slConsDisableGc(
+          newline,
+          slConsDisableGc(prevSpacePadding, slConsDisableGc(rbrace, SLEmpty))
+        )
         let colspace = ": "
         let comlf = ",\n"
-        for (let mut i = recordArity * 4n - 4n; i >= 0n;  i -= 4n) {
+        for (let mut i = recordArity * 4n - 4n; i >= 0n; i -= 4n) {
           let fieldName = WasmI32.toGrain(WasmI32.load(fields + i, 8n)): String
-          let fieldValue = toStringHelp(WasmI32.load(ptr + i, 16n), extraIndents + 1n, false)
-          Memory.incRef(WasmI32.fromGrain(spacePadding))
-          Memory.incRef(WasmI32.fromGrain(fieldName))
-          Memory.incRef(WasmI32.fromGrain(colspace))
-          strings = slConsDisableGc(spacePadding, slConsDisableGc(fieldName, slConsDisableGc(colspace, slConsDisableGc(fieldValue, strings))))
+          let fieldValue = toStringHelp(
+            WasmI32.load(ptr + i, 16n),
+            extraIndents + 1n,
+            false
+          )
+          strings = slConsDisableGc(
+            spacePadding,
+            slConsDisableGc(
+              fieldName,
+              slConsDisableGc(colspace, slConsDisableGc(fieldValue, strings))
+            )
+          )
+          Memory.decRef(WasmI32.fromGrain(fieldValue))
           if (i > 0n) {
-            Memory.incRef(WasmI32.fromGrain(comlf))
             strings = slConsDisableGc(comlf, strings)
           }
         }
-        strings = slConsDisableGc("{\n", strings)
+        let lbrace = "{\n"
+        strings = slConsDisableGc(lbrace, strings)
         let string = join(strings)
 
         Memory.decRef(WasmI32.fromGrain(strings))
         Memory.decRef(WasmI32.fromGrain(spacePadding))
         Memory.decRef(WasmI32.fromGrain(colspace))
         Memory.decRef(WasmI32.fromGrain(comlf))
+        Memory.decRef(WasmI32.fromGrain(lbrace))
+        Memory.decRef(WasmI32.fromGrain(rbrace))
+        Memory.decRef(WasmI32.fromGrain(newline))
 
         Memory.free(fields) // Avoid double-free of record field names
 
@@ -449,20 +507,24 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
     t when t == Tags._GRAIN_ARRAY_HEAP_TAG => {
       let arity = WasmI32.load(ptr, 4n)
       Memory.incRef(WasmI32.fromGrain(SLEmpty))
-      let mut strings = slConsDisableGc("]", SLEmpty)
+      let rbrack = "]"
+      let mut strings = slConsDisableGc(rbrack, SLEmpty)
       let comspace = ", "
       for (let mut i = arity * 4n - 4n; i >= 0n; i -= 4n) {
         let item = toStringHelp(WasmI32.load(ptr + i, 8n), extraIndents, false)
         strings = slConsDisableGc(item, strings)
+        Memory.decRef(WasmI32.fromGrain(item))
         if (i > 0n) {
-          Memory.incRef(WasmI32.fromGrain(comspace))
           strings = slConsDisableGc(comspace, strings)
         }
       }
-      strings = slConsDisableGc("[> ", strings)
+      let lbrack = "[> "
+      strings = slConsDisableGc(lbrack, strings)
       let string = join(strings)
       Memory.decRef(WasmI32.fromGrain(strings))
       Memory.decRef(WasmI32.fromGrain(comspace))
+      Memory.decRef(WasmI32.fromGrain(lbrack))
+      Memory.decRef(WasmI32.fromGrain(rbrack))
 
       string
     },
@@ -479,9 +541,16 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
           let numerator = NumberUtils.itoa32(WasmI32.load(ptr, 8n), 10n)
           let denominator = NumberUtils.itoa32(WasmI32.load(ptr, 12n), 10n)
           Memory.incRef(WasmI32.fromGrain(SLEmpty))
-          let strings = slConsDisableGc(numerator, slConsDisableGc("/", slConsDisableGc(denominator, SLEmpty)))
+          let slash = "/"
+          let strings = slConsDisableGc(
+            numerator,
+            slConsDisableGc(slash, slConsDisableGc(denominator, SLEmpty))
+          )
           let string = join(strings)
           Memory.decRef(WasmI32.fromGrain(strings))
+          Memory.decRef(WasmI32.fromGrain(numerator))
+          Memory.decRef(WasmI32.fromGrain(denominator))
+          Memory.decRef(WasmI32.fromGrain(slash))
           string
         },
         t when t == Tags._GRAIN_FLOAT32_BOXED_NUM_TAG => {
@@ -492,7 +561,7 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
         },
         _ => {
           "<unknown boxed number>"
-        }
+        },
       }
     },
     t when t == Tags._GRAIN_TUPLE_HEAP_TAG => {
@@ -503,30 +572,38 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
         WasmI32.store(ptr, 0x80000000n | tupleLength, 4n)
         let comspace = ", "
         Memory.incRef(WasmI32.fromGrain(SLEmpty))
-        let mut strings = slConsDisableGc(")", SLEmpty)
+        let rparen = ")"
+        let mut strings = slConsDisableGc(rparen, SLEmpty)
         if (tupleLength <= 1n) {
           // Special case: unary tuple
-          strings = slConsDisableGc(",", strings)
+          let comma = ","
+          strings = slConsDisableGc(comma, strings)
+          Memory.decRef(WasmI32.fromGrain(comma))
+          void
         }
         for (let mut i = tupleLength * 4n - 4n; i >= 0n; i -= 4n) {
-          let item = toStringHelp(WasmI32.load(ptr + i, 8n), extraIndents, false)
-          Memory.incRef(WasmI32.fromGrain(item))
-          Memory.incRef(WasmI32.fromGrain(strings))
+          let item = toStringHelp(
+            WasmI32.load(ptr + i, 8n),
+            extraIndents,
+            false
+          )
           strings = slConsDisableGc(item, strings)
+          Memory.decRef(WasmI32.fromGrain(item))
           if (i > 0n) {
-            Memory.incRef(WasmI32.fromGrain(comspace))
-            Memory.incRef(WasmI32.fromGrain(strings))
             strings = slConsDisableGc(comspace, strings)
           }
         }
         WasmI32.store(ptr, tupleLength, 4n)
 
         Memory.incRef(WasmI32.fromGrain(strings))
-        strings = slConsDisableGc("(", strings)
+        let lparen = "("
+        strings = slConsDisableGc(lparen, strings)
 
         let string = join(strings)
         Memory.decRef(WasmI32.fromGrain(strings))
         Memory.decRef(WasmI32.fromGrain(comspace))
+        Memory.decRef(WasmI32.fromGrain(rparen))
+        Memory.decRef(WasmI32.fromGrain(lparen))
 
         string
       }
@@ -538,14 +615,21 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
       Memory.incRef(WasmI32.fromGrain(SLEmpty))
       let strings = slConsDisableGc(
         "<unknown heap tag type: 0x",
-        slConsDisableGc(NumberUtils.itoa32(tag, 16n),
-        slConsDisableGc(" | value: 0x",
-        slConsDisableGc(NumberUtils.itoa32(ptr, 16n),
-        slConsDisableGc(">", SLEmpty)))))
+        slConsDisableGc(
+          NumberUtils.itoa32(tag, 16n),
+          slConsDisableGc(
+            " | value: 0x",
+            slConsDisableGc(
+              NumberUtils.itoa32(ptr, 16n),
+              slConsDisableGc(">", SLEmpty)
+            )
+          )
+        )
+      )
       let string = join(strings)
       Memory.decRef(WasmI32.fromGrain(strings))
       string
-    }
+    },
   }
 }, toStringHelp = (grainValue, extraIndents, toplevel) => {
   if ((grainValue & 1n) != 0n) {
@@ -567,7 +651,9 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
   let mut isFirst = true
 
   Memory.incRef(WasmI32.fromGrain(SLEmpty))
-  let mut strings = slConsDisableGc("[", SLEmpty)
+  let lbrack = "["
+  let commaspace = ", "
+  let mut strings = slConsDisableGc(lbrack, SLEmpty)
 
   while (true) {
     let variantId = WasmI32.load(cur, 12n) >> 1n // tagged number
@@ -575,24 +661,29 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
       break
     } else {
       if (!isFirst) {
-        strings = slConsDisableGc(", ", strings)
+        strings = slConsDisableGc(commaspace, strings)
       }
       isFirst = false
       let item = toStringHelp(WasmI32.load(cur, 20n), extraIndents, false)
       strings = slConsDisableGc(item, strings)
+      Memory.decRef(WasmI32.fromGrain(item))
       cur = WasmI32.load(cur, 24n)
     }
   }
-  strings = slConsDisableGc("]", strings)
+  let rbrack = "]"
+  strings = slConsDisableGc(rbrack, strings)
   let reversed = reverse(strings)
   let string = join(reversed)
   Memory.decRef(WasmI32.fromGrain(strings))
   Memory.decRef(WasmI32.fromGrain(reversed))
+  Memory.decRef(WasmI32.fromGrain(lbrack))
+  Memory.decRef(WasmI32.fromGrain(rbrack))
+  Memory.decRef(WasmI32.fromGrain(commaspace))
   string
 }
 
 @disableGC
-export let rec toString = (value) => {
+export let rec toString = value => {
   let value = WasmI32.fromGrain(value)
   let ret = toStringHelp(value, 0n, true)
   Memory.decRef(value)
@@ -601,7 +692,7 @@ export let rec toString = (value) => {
 }
 
 @disableGC
-export let rec print = (value) => {
+export let rec print = value => {
   // First convert the value to string, if it isn't one already. Calling
   // toString will either return value instance itself if it's already a
   // string, or a new string with the content of value object, which will need

package/runtime/stringUtils.gr

@@ -0,0 +1,176 @@
+// TODO(#1050): Remove dependency on Pervasives once Option/Result types are imbedded in the compiler
+
+import WasmI32, {
+  add as (+),
+  sub as (-),
+  gtU as (>),
+  geU as (>=),
+  ltU as (<),
+  shrS as (>>),
+  eq as (==),
+  ne as (!=),
+  and as (&),
+} from "runtime/unsafe/wasmi32"
+import WasmI64 from "runtime/unsafe/wasmi64"
+import Memory from "runtime/unsafe/memory"
+import Tags from "runtime/unsafe/tags"
+import { reducedInteger } from "runtime/numbers"
+
+@disableGC
+export let rec parseInt = (string: String, radix: Number) => {
+  let _CHAR_0 = 0x30n
+  let _CHAR_B = 0x42n
+  let _CHAR_b = 0x62n
+  let _CHAR_O = 0x4fn
+  let _CHAR_o = 0x6fn
+  let _CHAR_X = 0x58n
+  let _CHAR_x = 0x78n
+
+  let _CHAR_A = 0x41n
+  let _CHAR_a = 0x61n
+
+  let _CHAR_UNDERSCORE = 0x5fn
+  let _CHAR_MINUS = 0x2dn
+
+  let _INT_MIN = -9223372036854775808N
+
+  // Don't need to process Unicode length since if the string
+  // contains non-ascii characters, it's not a valid integer
+  let strLen = WasmI32.load(WasmI32.fromGrain(string), 4n)
+
+  // Our pointer within the string we're parsing, offset by the
+  // header
+  let mut offset = WasmI32.fromGrain(string) + 8n
+
+  let strEnd = offset + strLen
+
+  let radix = WasmI32.fromGrain(radix)
+  let result = if (
+    WasmI32.eqz(radix & Tags._GRAIN_NUMBER_TAG_MASK) ||
+    radix < WasmI32.fromGrain(2) ||
+    radix > WasmI32.fromGrain(36)
+  ) {
+    Memory.incRef(WasmI32.fromGrain(Err))
+    Err("Radix must be an integer between 2 and 36")
+  } else if (WasmI32.eqz(strLen)) {
+    Memory.incRef(WasmI32.fromGrain(Err))
+    Err("Invalid input")
+  } else {
+    let mut char = WasmI32.load8U(offset, 0n)
+
+    let mut limit = WasmI64.add(_INT_MIN, 1N)
+
+    // Check for a sign
+    let mut negative = false
+    if (char == _CHAR_MINUS) {
+      negative = true
+      offset += 1n
+      limit = _INT_MIN
+      char = WasmI32.load8U(offset, 0n)
+    }
+
+    let mut radix = WasmI64.extendI32S(radix >> 1n)
+
+    // Check if we should override the supplied radix
+    if (char == _CHAR_0 && strLen > 2n) {
+      match (WasmI32.load8U(offset, 1n)) {
+        c when c == _CHAR_B || c == _CHAR_b => {
+          radix = 2N
+          offset += 2n
+        },
+        c when c == _CHAR_O || c == _CHAR_o => {
+          radix = 8N
+          offset += 2n
+        },
+        c when c == _CHAR_X || c == _CHAR_x => {
+          radix = 16N
+          offset += 2n
+        },
+        _ => void,
+      }
+    }
+
+    let mut value = 0N
+
+    // we use 0 to represent no error, 1 to represent an invalid
+    // input, and 2 to represent an overflow
+    let mut error = 1n
+
+    for (let mut i = offset; i < strEnd; i += 1n) {
+      let char = WasmI32.load8U(i, 0n)
+
+      // Ignore underscore characters
+      if (char == _CHAR_UNDERSCORE) {
+        continue
+      }
+
+      // We've seen at least one non-underscore character, so we'll consider
+      // the input valid until we find out otherwise
+
+      error = 0n
+
+      let mut digit = 0n
+
+      match (char) {
+        c when c - _CHAR_0 < 10n => digit = char - _CHAR_0,
+        c when c - _CHAR_A < 26n => digit = char - _CHAR_A + 10n,
+        c when c - _CHAR_a < 26n => digit = char - _CHAR_a + 10n,
+        _ => {
+          error = 1n
+          // invalid digit
+          break
+        },
+      }
+
+      if (digit >= WasmI32.wrapI64(radix)) {
+        error = 1n
+        // invalid digit
+        break
+      }
+
+      let digit = WasmI64.extendI32U(digit)
+
+      value = WasmI64.mul(value, radix)
+
+      // Check for overflow
+      // 64-bit int min + 1
+      if (WasmI64.ltS(value, WasmI64.add(limit, digit))) {
+        error = 2n
+        // overflow
+        break
+      }
+
+      // To quote the OpenJDK,
+      // "Accumulating negatively avoids surprises near MAX_VALUE"
+      // The minimum value of a 64-bit integer (-9223372036854775808) can't be
+      // represented as a positive number because it would be larger than the
+      // maximum 64-bit integer (9223372036854775807), so we'd be unable to
+      // parse negatives as positives and multiply by the sign at the end.
+      // Instead, we represent all positive numbers as negative numbers since
+      // we have one unit more headroom.
+      value = WasmI64.sub(value, digit)
+    }
+
+    match (error) {
+      1n => {
+        Memory.incRef(WasmI32.fromGrain(Err))
+        Err("Invalid digit in input")
+      },
+      2n => {
+        Memory.incRef(WasmI32.fromGrain(Err))
+        Err("Input out of range of representable integers")
+      },
+      _ => {
+        let value = if (negative) value else WasmI64.mul(value, -1N)
+        let number = WasmI32.toGrain(reducedInteger(value)): Number
+        Memory.incRef(WasmI32.fromGrain(Ok))
+        Ok(number)
+      },
+    }
+  }
+
+  Memory.decRef(WasmI32.fromGrain(parseInt))
+  Memory.decRef(radix)
+
+  result
+}