@grain/stdlib 0.5.3 → 0.5.5

package/runtime/atof/table.md

@@ -0,0 +1,12 @@
+### Table.**get_F64_POWERS10_FAST_PATH**
+
+```grain
+get_F64_POWERS10_FAST_PATH : () -> WasmI32
+```
+
+### Table.**get_POWERS5**
+
+```grain
+get_POWERS5 : () -> WasmI32
+```
+

package/runtime/{stringUtils.gr → atoi/parse.gr}

@@ -18,7 +18,7 @@ import BI from "runtime/bigint"
 import { reducedInteger } from "runtime/numbers"
 
 @unsafe
-export let rec parseInt = (string: String, radix: Number) => {
+export let parseInt = (string: String, radix: Number) => {
   let _CHAR_0 = 0x30n
   let _CHAR_B = 0x42n
   let _CHAR_b = 0x62n

package/runtime/{stringUtils.md → atoi/parse.md}

@@ -1,4 +1,4 @@
-### StringUtils.**parseInt**
+### Parse.**parseInt**
 
 ```grain
 parseInt : (String, Number) -> Result<Number, String>

package/runtime/bigint.gr

@@ -786,7 +786,7 @@ let _SIZES = [>
 ]
 
 @unsafe
-export let rec bigIntToString = (num: WasmI32, base: WasmI32) => {
+export let bigIntToString = (num: WasmI32, base: WasmI32) => {
   let getDigit = n =>
     WasmI32.load8U(WasmI32.add(WasmI32.fromGrain(_DIGITS), n), 8n)
   if (WasmI32.ltS(base, 2n) || WasmI32.gtS(base, 32n)) {
@@ -1339,7 +1339,7 @@ export let shl = (num: WasmI32, places: WasmI32) => {
   let (&) = WasmI64.and
   let a = places / 32n
   let b = places % 32n
-  let mask = (1N << WasmI64.extendI32U(b)) - 1N << 64N - WasmI64.extendI32U(b)
+  let mask = ((1N << WasmI64.extendI32U(b)) - 1N) << 64N - WasmI64.extendI32U(b)
   let result = init(numLimbs + a)
   setFlag(result, _IS_NEGATIVE, getFlag(num, _IS_NEGATIVE))
   let numHalfLimbs = WasmI32.shl(numLimbs, 1n)
@@ -1350,7 +1350,7 @@ export let shl = (num: WasmI32, places: WasmI32) => {
     setHalfLimb(
       result,
       i + a,
-      WasmI32.wrapI64(acc << WasmI64.extendI32U(b) >> 32N)
+      WasmI32.wrapI64((acc << WasmI64.extendI32U(b)) >> 32N)
     )
   }
   let (>) = WasmI64.gtU
@@ -1827,10 +1827,10 @@ let baseCaseDivRem = (a: WasmI32, b: WasmI32, result: WasmI32) => {
   let n = getHalfSize(b)
   let m = getHalfSize(a) - n
   let qsize = (if (WasmI32.eqz(WasmI32.and(m + 1n, 1n))) {
-        m + 1n
-      } else {
-        m + 2n
-      }) >>
+      m + 1n
+    } else {
+      m + 2n
+    }) >>
     1n
   let mut q = init(qsize)
   let mut a = 0n

package/runtime/compare.gr

@@ -146,7 +146,8 @@ let rec heapCompareHelp = (heapTag, xptr, yptr) => {
       tagSimpleNumber(xptr - yptr)
     },
   }
-}, compareHelp = (x, y) => {
+},
+compareHelp = (x, y) => {
   let xtag = x & Tags._GRAIN_GENERIC_TAG_MASK
   let ytag = y & Tags._GRAIN_GENERIC_TAG_MASK
   if ((xtag & ytag) != Tags._GRAIN_GENERIC_HEAP_TAG_TYPE) {

package/runtime/equal.gr

@@ -189,7 +189,8 @@ let rec heapEqualHelp = (heapTag, xptr, yptr) => {
       xptr == yptr
     },
   }
-}, equalHelp = (x, y) => {
+},
+equalHelp = (x, y) => {
   if (
     (x & Tags._GRAIN_GENERIC_TAG_MASK) != 0n &&
     (y & Tags._GRAIN_GENERIC_TAG_MASK) != 0n
@@ -207,6 +208,6 @@ let rec heapEqualHelp = (heapTag, xptr, yptr) => {
 }
 
 @unsafe
-export let rec equal = (x: a, y: a) => {
+export let equal = (x: a, y: a) => {
   equalHelp(WasmI32.fromGrain(x), WasmI32.fromGrain(y))
 }

package/runtime/exception.gr

@@ -9,6 +9,8 @@ import foreign wasm fd_write: (
   WasmI32,
 ) -> WasmI32 from "wasi_snapshot_preview1"
 
+primitive unreachable: () -> a = "@unreachable"
+
 enum Option<a> {
   Some(a),
   None,
@@ -79,8 +81,8 @@ let exceptionToString = (e: Exception) => {
 // the runtime heap, but this is the only module that needs to do it
 let iov = WasmI32.fromGrain([> 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n])
 
-export let printException = (e: Exception) => {
-  let ptr = WasmI32.fromGrain(exceptionToString(e))
+export let panic = (msg: String) => {
+  let ptr = WasmI32.fromGrain(msg)
   let written = iov + 32n
   let lf = iov + 36n
   WasmI32.store(iov, ptr + 8n, 0n)
@@ -89,7 +91,11 @@ export let printException = (e: Exception) => {
   WasmI32.store(iov, lf, 8n)
   WasmI32.store(iov, 1n, 12n)
   fd_write(2n, iov, 2n, written)
-  void
+  unreachable()
+}
+
+export let panicWithException = (e: Exception) => {
+  panic(exceptionToString(e))
 }
 
 export exception IndexOutOfBounds
@@ -109,7 +115,6 @@ export exception MatchFailure
  */
 export exception AssertionError(String)
 export exception InvalidArgument(String)
-export exception OutOfMemory
 
 let runtimeErrorPrinter = e => {
   match (e) {
@@ -123,7 +128,6 @@ let runtimeErrorPrinter = e => {
       Some("NumberNotRational: Can't coerce number to rational"),
     MatchFailure => Some("MatchFailure: No matching pattern"),
     AssertionError(s) => Some(s),
-    OutOfMemory => Some("OutOfMemory: Maximum memory size exceeded"),
     InvalidArgument(msg) => Some(msg),
     _ => None,
   }

package/runtime/exception.md

@@ -22,9 +22,15 @@ dangerouslyRegisterBasePrinter : a -> Void
 dangerouslyRegisterPrinter : a -> Void
 ```
 
-### Exception.**printException**
+### Exception.**panic**
 
 ```grain
-printException : Exception -> Void
+panic : String -> a
+```
+
+### Exception.**panicWithException**
+
+```grain
+panicWithException : Exception -> a
 ```
 

package/runtime/gc.gr

@@ -213,7 +213,8 @@ let rec decRef = (userPtr: WasmI32, ignoreZeros: Bool) => {
   } else {
     userPtr
   }
-}, decRefChildren = (userPtr: WasmI32) => {
+},
+decRefChildren = (userPtr: WasmI32) => {
   match (WasmI32.load(userPtr, 0n)) {
     t when t == Tags._GRAIN_BOXED_NUM_HEAP_TAG => {
       let tag = WasmI32.load(userPtr, 4n)

package/runtime/malloc.gr

@@ -28,8 +28,6 @@ primitive (!): Bool -> Bool = "@not"
 primitive (&&): (Bool, Bool) -> Bool = "@and"
 primitive (||): (Bool, Bool) -> Bool = "@or"
 
-primitive throw: Exception -> a = "@throw"
-
 primitive heapBase: WasmI32 = "@heap.base"
 
 /* UNDERSTANDING THE STRUCTURE OF THE FREE LIST
@@ -221,7 +219,7 @@ let morecore = (nbytes: WasmI32) => {
 
   // If there was an error, fail
   if (cp == -1n) {
-    throw Exception.OutOfMemory
+    Exception.panic("OutOfMemory: Maximum memory size exceeded")
   } else {
     // Set the size of the new block to the amount the
     // heap was grown.

package/runtime/numberUtils.gr

@@ -46,7 +46,7 @@ let _I32_MAX = 0xffffffffN
 let mut _POWERS10 = -1n
 
 @unsafe
-let get_POWERS10 = () => {
+export let get_POWERS10 = () => {
   if (_POWERS10 == -1n) {
     _POWERS10 = Memory.malloc(40n)
     WasmI32.store(_POWERS10, 1n, 0n)
@@ -728,16 +728,16 @@ export let decimalCount32 = value => {
       1n + (if (WasmI32.geU(value, 10n)) 1n else 0n)
     } else {
       3n +
-      (if (WasmI32.geU(value, 10000n)) 1n else 0n) +
-      (if (WasmI32.geU(value, 1000n)) 1n else 0n)
+        (if (WasmI32.geU(value, 10000n)) 1n else 0n) +
+        (if (WasmI32.geU(value, 1000n)) 1n else 0n)
     }
   } else {
     if (WasmI32.ltU(value, 10000000n)) {
       6n + (if (WasmI32.geU(value, 1000000n)) 1n else 0n)
     } else {
       8n +
-      (if (WasmI32.geU(value, 1000000000n)) 1n else 0n) +
-      (if (WasmI32.geU(value, 100000000n)) 1n else 0n)
+        (if (WasmI32.geU(value, 1000000000n)) 1n else 0n) +
+        (if (WasmI32.geU(value, 100000000n)) 1n else 0n)
     }
   }
 }
@@ -749,20 +749,20 @@ let decimalCount64High = value => {
   if (WasmI64.ltU(value, 1000000000000000N)) {
     if (WasmI64.ltU(value, 1000000000000N)) {
       10n +
-      (if (WasmI64.geU(value, 100000000000N)) 1n else 0n) +
-      (if (WasmI64.geU(value, 10000000000N)) 1n else 0n)
+        (if (WasmI64.geU(value, 100000000000N)) 1n else 0n) +
+        (if (WasmI64.geU(value, 10000000000N)) 1n else 0n)
     } else {
       13n +
-      (if (WasmI64.geU(value, 100000000000000N)) 1n else 0n) +
-      (if (WasmI64.geU(value, 10000000000000N)) 1n else 0n)
+        (if (WasmI64.geU(value, 100000000000000N)) 1n else 0n) +
+        (if (WasmI64.geU(value, 10000000000000N)) 1n else 0n)
     }
   } else {
     if (WasmI64.ltU(value, 100000000000000000N)) {
       16n + (if (WasmI64.geU(value, 10000000000000000N)) 1n else 0n)
     } else {
       18n +
-      (if (WasmI64.geU(value, 0x8AC7230489E80000N)) 1n else 0n) +
-      (if (WasmI64.geU(value, 1000000000000000000N)) 1n else 0n)
+        (if (WasmI64.geU(value, 0x8AC7230489E80000N)) 1n else 0n) +
+        (if (WasmI64.geU(value, 1000000000000000000N)) 1n else 0n)
     }
   }
 }
@@ -774,7 +774,7 @@ let ulog_base = (num, base) => {
       63n - WasmI32.wrapI64(WasmI64.clz(num)),
       31n - WasmI32.clz(base)
     ) +
-    1n
+      1n
   } else {
     let b64 = WasmI64.extendI32U(base)
     let mut b = b64
@@ -1277,7 +1277,7 @@ let genDigits = (buffer, w_frc, mp_frc, mp_exp, delta, sign) => {
         wp_w_frc = WasmI64.mul(
           wp_w_frc,
           WasmI64.extendI32U(
-            WasmI32.load(get_POWERS10() + (0n - kappa << 2n), 0n)
+            WasmI32.load(get_POWERS10() + ((0n - kappa) << 2n), 0n)
           )
         )
         grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc)

package/runtime/numberUtils.md

@@ -4,6 +4,12 @@
 _MAX_DOUBLE_LENGTH : WasmI32
 ```
 
+### NumberUtils.**get_POWERS10**
+
+```grain
+get_POWERS10 : () -> WasmI32
+```
+
 ### NumberUtils.**get_HEX_DIGITS**
 
 ```grain