@grain/stdlib 0.5.3 → 0.5.5

package/runtime/numbers.gr

@@ -79,7 +79,7 @@ export let isFloat = x => {
   if (isBoxedNumber(x)) {
     let tag = WasmI32.load(x, 4n)
     WasmI32.eq(tag, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) ||
-    WasmI32.eq(tag, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)
+      WasmI32.eq(tag, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)
   } else {
     false
   }
@@ -90,8 +90,8 @@ 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)
+      WasmI32.eq(tag, Tags._GRAIN_INT64_BOXED_NUM_TAG) ||
+      WasmI32.eq(tag, Tags._GRAIN_BIGINT_BOXED_NUM_TAG)
   } else {
     true
   }
@@ -518,13 +518,13 @@ let isIntegerF64 = value => {
 @unsafe
 let isSafeIntegerF32 = value => {
   WasmF32.le(WasmF32.abs(value), _F32_MAX_SAFE_INTEGER) &&
-  WasmF32.eq(WasmF32.trunc(value), value)
+    WasmF32.eq(WasmF32.trunc(value), value)
 }
 
 @unsafe
 let isSafeIntegerF64 = value => {
   WasmF64.le(WasmF64.abs(value), _F64_MAX_SAFE_INTEGER) &&
-  WasmF64.eq(WasmF64.trunc(value), value)
+    WasmF64.eq(WasmF64.trunc(value), value)
 }
 
 /** Number-aware equality checking
@@ -564,12 +564,12 @@ let numberEqualSimpleHelp = (x, y) => {
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat32Number(y)
         isSafeIntegerF32(yBoxedVal) &&
-        WasmF32.eq(WasmF32.convertI32S(xval), yBoxedVal)
+          WasmF32.eq(WasmF32.convertI32S(xval), yBoxedVal)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat64Number(y)
         isSafeIntegerF64(yBoxedVal) &&
-        WasmF64.eq(WasmF64.convertI32S(xval), yBoxedVal)
+          WasmF64.eq(WasmF64.convertI32S(xval), yBoxedVal)
       },
       _ => {
         throw UnknownNumberTag
@@ -606,12 +606,12 @@ let numberEqualInt64Help = (xBoxedVal, y) => {
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat32Number(y)
         isSafeIntegerF32(yBoxedVal) &&
-        WasmI64.eq(xBoxedVal, WasmI64.truncF32S(yBoxedVal))
+          WasmI64.eq(xBoxedVal, WasmI64.truncF32S(yBoxedVal))
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat64Number(y)
         isSafeIntegerF64(yBoxedVal) &&
-        WasmI64.eq(xBoxedVal, WasmI64.truncF64S(yBoxedVal))
+          WasmI64.eq(xBoxedVal, WasmI64.truncF64S(yBoxedVal))
       },
       _ => {
         throw UnknownNumberTag
@@ -843,14 +843,16 @@ let numberAddSubSimpleHelp = (x, y, isSub) => {
       t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
         let xval = WasmI64.extendI32S(xval)
         let yBoxedVal = WasmI64.extendI32S(boxedInt32Number(y))
-        let result = if (isSub) WasmI64.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmI64.sub(xval, yBoxedVal)
           else WasmI64.add(xval, yBoxedVal)
         reducedInteger(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedInt64Number(y)
         let xval64 = WasmI64.extendI32S(xval)
-        let result = if (isSub) WasmI64.sub(xval64, yBoxedVal)
+        let result =
+          if (isSub) WasmI64.sub(xval64, yBoxedVal)
           else WasmI64.add(xval64, yBoxedVal)
         if (
           WasmI64.geS(yBoxedVal, 0N) && WasmI64.ltS(result, xval64) ||
@@ -884,7 +886,8 @@ let numberAddSubSimpleHelp = (x, y, isSub) => {
         let yDenominator = boxedRationalDenominator(y)
         let expandedXNumerator = BI.mul(xBig, yDenominator)
         Memory.decRef(xBig)
-        let result = if (isSub) BI.sub(expandedXNumerator, yNumerator)
+        let result =
+          if (isSub) BI.sub(expandedXNumerator, yNumerator)
           else BI.add(expandedXNumerator, yNumerator)
         let ret = reducedFractionBigInt(result, yDenominator)
         Memory.decRef(expandedXNumerator)
@@ -894,14 +897,16 @@ let numberAddSubSimpleHelp = (x, y, isSub) => {
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat32Number(y)
         let xval = WasmF32.convertI32S(xval)
-        let result = if (isSub) WasmF32.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF32.sub(xval, yBoxedVal)
           else WasmF32.add(xval, yBoxedVal)
         newFloat32(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat64Number(y)
         let xval = WasmF64.convertI32S(xval)
-        let result = if (isSub) WasmF64.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF64.sub(xval, yBoxedVal)
           else WasmF64.add(xval, yBoxedVal)
         newFloat64(result)
       },
@@ -940,14 +945,16 @@ let numberAddSubInt64Help = (xval, y, isSub) => {
     match (yBoxedNumberTag) {
       t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
         let yBoxedVal = WasmI64.extendI32S(boxedInt32Number(y))
-        let result = if (isSub) WasmI64.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmI64.sub(xval, yBoxedVal)
           else WasmI64.add(xval, yBoxedVal)
         reducedInteger(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedInt64Number(y)
         let xval64 = xval
-        let result = if (isSub) WasmI64.sub(xval64, yBoxedVal)
+        let result =
+          if (isSub) WasmI64.sub(xval64, yBoxedVal)
           else WasmI64.add(xval64, yBoxedVal)
         if (
           WasmI64.geS(yBoxedVal, 0N) && WasmI64.ltS(result, xval64) ||
@@ -981,7 +988,8 @@ let numberAddSubInt64Help = (xval, y, isSub) => {
         let yDenominator = boxedRationalDenominator(y)
         let expandedXNumerator = BI.mul(xBig, yDenominator)
         Memory.decRef(xBig)
-        let result = if (isSub) BI.sub(expandedXNumerator, yNumerator)
+        let result =
+          if (isSub) BI.sub(expandedXNumerator, yNumerator)
           else BI.add(expandedXNumerator, yNumerator)
         let ret = reducedFractionBigInt(result, yDenominator)
         Memory.decRef(expandedXNumerator)
@@ -991,14 +999,16 @@ let numberAddSubInt64Help = (xval, y, isSub) => {
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let xval = WasmF32.convertI64S(xval)
         let yBoxedVal = boxedFloat32Number(y)
-        let result = if (isSub) WasmF32.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF32.sub(xval, yBoxedVal)
           else WasmF32.add(xval, yBoxedVal)
         newFloat32(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let xval = WasmF64.convertI64S(xval)
         let yBoxedVal = boxedFloat64Number(y)
-        let result = if (isSub) WasmF64.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF64.sub(xval, yBoxedVal)
           else WasmF64.add(xval, yBoxedVal)
         newFloat64(result)
       },
@@ -1092,7 +1102,8 @@ let numberAddSubBigIntHelp = (x, y, isSub) => {
         let yNumerator = boxedRationalNumerator(y)
         let yDenominator = boxedRationalDenominator(y)
         let expandedXNumerator = BI.mul(x, yDenominator)
-        let result = if (isSub) BI.sub(expandedXNumerator, yNumerator)
+        let result =
+          if (isSub) BI.sub(expandedXNumerator, yNumerator)
           else BI.add(expandedXNumerator, yNumerator)
         Memory.decRef(expandedXNumerator)
         let ret = reducedFractionBigInt(result, yDenominator)
@@ -1102,14 +1113,16 @@ let numberAddSubBigIntHelp = (x, y, isSub) => {
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let xval = BI.toFloat32(x)
         let yBoxedVal = boxedFloat32Number(y)
-        let result = if (isSub) WasmF32.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF32.sub(xval, yBoxedVal)
           else WasmF32.add(xval, yBoxedVal)
         newFloat32(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let xval = BI.toFloat64(x)
         let yBoxedVal = boxedFloat64Number(y)
-        let result = if (isSub) WasmF64.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF64.sub(xval, yBoxedVal)
           else WasmF64.add(xval, yBoxedVal)
         newFloat64(result)
       },
@@ -1128,7 +1141,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
     let yval = untagSimple(y)
     let yBig = BI.makeWrappedInt32(yval)
     let expandedYNumerator = BI.mul(xDenominator, yBig)
-    let result = if (isSub) BI.sub(xNumerator, expandedYNumerator)
+    let result =
+      if (isSub) BI.sub(xNumerator, expandedYNumerator)
       else BI.add(xNumerator, expandedYNumerator)
     Memory.decRef(expandedYNumerator)
     Memory.decRef(yBig)
@@ -1145,7 +1159,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
         let yNumerator = boxedRationalNumerator(y)
         let yDenominator = boxedRationalDenominator(y)
         if (BI.eq(xDenominator, yDenominator)) {
-          let newNumerator = if (isSub) BI.sub(xNumerator, yNumerator)
+          let newNumerator =
+            if (isSub) BI.sub(xNumerator, yNumerator)
             else BI.add(xNumerator, yNumerator)
           let ret = reducedFractionBigInt(newNumerator, xDenominator)
           Memory.decRef(newNumerator)
@@ -1153,7 +1168,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
         } else {
           let numerator1 = BI.mul(xNumerator, yDenominator)
           let numerator2 = BI.mul(yNumerator, xDenominator)
-          let numerator = if (isSub) BI.sub(numerator1, numerator2)
+          let numerator =
+            if (isSub) BI.sub(numerator1, numerator2)
             else BI.add(numerator1, numerator2)
           let denominator = BI.mul(xDenominator, yDenominator)
           let ret = reducedFractionBigInt(numerator, denominator)
@@ -1167,7 +1183,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
         let yBig = BI.makeWrappedInt32(boxedInt32Number(y))
         let expandedYNumerator = BI.mul(yBig, xDenominator)
         Memory.decRef(yBig)
-        let result = if (isSub) BI.sub(xNumerator, expandedYNumerator)
+        let result =
+          if (isSub) BI.sub(xNumerator, expandedYNumerator)
           else BI.add(xNumerator, expandedYNumerator)
         let ret = reducedFractionBigInt(result, xDenominator)
         Memory.decRef(expandedYNumerator)
@@ -1178,7 +1195,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
         let yBig = BI.makeWrappedInt64(boxedInt64Number(y))
         let expandedYNumerator = BI.mul(yBig, xDenominator)
         Memory.decRef(yBig)
-        let result = if (isSub) BI.sub(xNumerator, expandedYNumerator)
+        let result =
+          if (isSub) BI.sub(xNumerator, expandedYNumerator)
           else BI.add(xNumerator, expandedYNumerator)
         let ret = reducedFractionBigInt(result, xDenominator)
         Memory.decRef(expandedYNumerator)
@@ -1187,7 +1205,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
       },
       t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
         let expandedYNumerator = BI.mul(xDenominator, y)
-        let result = if (isSub) BI.sub(xNumerator, expandedYNumerator)
+        let result =
+          if (isSub) BI.sub(xNumerator, expandedYNumerator)
           else BI.add(xNumerator, expandedYNumerator)
         Memory.decRef(expandedYNumerator)
         let ret = reducedFractionBigInt(result, xDenominator)
@@ -1199,7 +1218,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
           BI.toFloat32(xNumerator),
           BI.toFloat32(xDenominator)
         )
-        let result = if (isSub) WasmF32.sub(xval, boxedFloat32Number(y))
+        let result =
+          if (isSub) WasmF32.sub(xval, boxedFloat32Number(y))
           else WasmF32.add(xval, boxedFloat32Number(y))
         newFloat32(result)
       },
@@ -1208,8 +1228,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
         let xdenfloat = BI.toFloat64(xDenominator)
         let xval = WasmF64.div(xnumfloat, xdenfloat)
         let yval = boxedFloat64Number(y)
-        let result = if (isSub) WasmF64.sub(xval, yval)
-          else WasmF64.add(xval, yval)
+        let result =
+          if (isSub) WasmF64.sub(xval, yval) else WasmF64.add(xval, yval)
         let ret = newFloat64(result)
         ret
       },
@@ -1404,6 +1424,13 @@ let numberTimesDivideBigIntHelp = (x, y, isDivide) => {
         Memory.decRef(yBig)
         ret
       },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        if (isDivide) {
+          reducedFractionBigInt(x, y)
+        } else {
+          reducedBigInteger(BI.mul(x, y))
+        }
+      },
       t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
         let yNumerator = boxedRationalNumerator(y)
         let yDenominator = boxedRationalDenominator(y)
@@ -1548,9 +1575,11 @@ let numberTimesDivideRationalHelp = (x, y, isDivide) => {
         let yDenominator = boxedRationalDenominator(y)
         // (a / b) * (c / d) == (a * c) / (b * d)
         // (a / b) / (c / d) == (a * d) / (b * c)
-        let numerator = if (isDivide) BI.mul(xNumerator, yDenominator)
+        let numerator =
+          if (isDivide) BI.mul(xNumerator, yDenominator)
           else BI.mul(xNumerator, yNumerator)
-        let denominator = if (isDivide) BI.mul(xDenominator, yNumerator)
+        let denominator =
+          if (isDivide) BI.mul(xDenominator, yNumerator)
           else BI.mul(xDenominator, yDenominator)
         reducedFractionBigInt(numerator, denominator)
       },
@@ -1686,7 +1715,8 @@ let numberMod = (x, y) => {
     WasmI64.gtS(xval, 0N) && WasmI64.ltS(yval, 0N)
   ) {
     let modval = WasmI64.remS(i64abs(xval), i64abs(yval))
-    let result = if (WasmI64.ne(modval, 0N))
+    let result =
+      if (WasmI64.ne(modval, 0N))
         WasmI64.mul(
           WasmI64.sub(i64abs(yval), modval),
           if (WasmI64.ltS(yval, 0N)) -1N else 1N
@@ -1702,9 +1732,9 @@ let numberMod = (x, y) => {
  * Int/int and float/float comparisons are always accurate.
  * Rational/rational comparisons are approximations with the exception of
  * equality, which is always accurate.
- * 
+ *
  * Values compared to floats or rationals are first converted to floats.
- * 
+ *
  * All comparison operators consider NaN not equal to, less than, or greater
  * than NaN, with the exception of `compare`, which considers NaN equal to
  * itself and otherwise smaller than any other float value. This provides a
@@ -2190,7 +2220,7 @@ export let (>>) = (x: Number, y: Number) => {
 //         we will fail if attempting to coerce to an int!
 
 @unsafe
-export let rec coerceNumberToInt32 = (x: Number) => {
+export let coerceNumberToInt32 = (x: Number) => {
   let x = WasmI32.fromGrain(x)
   let result = if (
     !isSimpleNumber(x) &&
@@ -2209,7 +2239,7 @@ export let rec coerceNumberToInt32 = (x: Number) => {
 }
 
 @unsafe
-export let rec coerceNumberToInt64 = (x: Number) => {
+export let coerceNumberToInt64 = (x: Number) => {
   let x = WasmI32.fromGrain(x)
   let result = if (
     !isSimpleNumber(x) &&
@@ -2227,7 +2257,7 @@ export let rec coerceNumberToInt64 = (x: Number) => {
 }
 
 @unsafe
-export let rec coerceNumberToBigInt = (x: Number) => {
+export let coerceNumberToBigInt = (x: Number) => {
   let x = WasmI32.fromGrain(x)
   let result = if (isBigInt(x)) {
     // avoid extra malloc and prevent x from being freed
@@ -2459,3 +2489,57 @@ export let isBigInt = x => {
   let x = WasmI32.fromGrain(x)
   isBigInt(x)
 }
+
+// Scalbn is based on https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c
+/*
+ * ====================================================
+ * Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+/**
+ * Multiplies a floating-point number by an integral power of 2.
+ *
+ * @param x: The floating-point value
+ * @param n: The Integer exponent
+ * @returns The result of x * 2^n
+ *
+ * @since v0.5.4
+ */
+@unsafe
+export let scalbn = (x, n) => {
+  let (>) = WasmI32.gtS
+  let (<) = WasmI32.ltS
+  let (*) = WasmF64.mul
+  let (-) = WasmI32.sub
+  let (+) = WasmI32.add
+  let (<<) = WasmI64.shl
+  // Constants
+  let const_0x1p1023 = 8.98847e+307W
+  let const_0x1p_1022 = 2.22507e-308W
+  let const_0x1p53 = 9.0072e+15W
+  let mut n = n
+  let mut y = x
+  if (n > 1023n) {
+    y *= const_0x1p1023
+    n -= 1023n
+    if (n > 1023n) {
+      y *= const_0x1p1023
+      n -= 1023n
+      if (n > 1023n) n = 1023n
+    } else if (n < -1023n) {
+      /* make sure final n < -53 to avoid double rounding in the subnormal range */
+      y *= const_0x1p_1022 * const_0x1p53
+      n += 1022n - 53n
+      if (n < -1022n) {
+        y *= const_0x1p_1022 * const_0x1p53
+        n += 1022n - 53n
+        if (n < -1022n) n = -1022n
+      }
+    }
+  }
+  y * WasmF64.reinterpretI64(WasmI64.extendI32S(0x3FFn + n) << 52N)
+}

package/runtime/numbers.md

@@ -322,3 +322,29 @@ decr : Number -> Number
 isBigInt : a -> Bool
 ```
 
+### Numbers.**scalbn**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.4</code></summary>
+No other changes yet.
+</details>
+
+```grain
+scalbn : (WasmF64, WasmI32) -> WasmF64
+```
+
+Multiplies a floating-point number by an integral power of 2.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`x`|`WasmF64`|The floating-point value|
+|`n`|`WasmI32`|The Integer exponent|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmF64`|The result of x * 2^n|
+

package/runtime/string.gr

@@ -547,7 +547,8 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
       join(strings)
     },
   }
-}, toStringHelp = (grainValue, extraIndents, toplevel) => {
+},
+toStringHelp = (grainValue, extraIndents, toplevel) => {
   if ((grainValue & 1n) != 0n) {
     // Simple (unboxed) numbers
     NumberUtils.itoa32(grainValue >> 1n, 10n)
@@ -572,7 +573,8 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
       "<unknown value>"
     }
   }
-}, listToString = (ptr, extraIndents) => {
+},
+listToString = (ptr, extraIndents) => {
   let mut cur = ptr
   let mut isFirst = true
 

package/runtime/unsafe/conv.gr

@@ -1,69 +1,53 @@
-import Memory from "runtime/unsafe/memory"
 import WasmI32 from "runtime/unsafe/wasmi32"
 import WasmI64 from "runtime/unsafe/wasmi64"
 import WasmF32 from "runtime/unsafe/wasmf32"
 import WasmF64 from "runtime/unsafe/wasmf64"
-import Tags from "runtime/unsafe/tags"
-
-@disableGC
+import {
+  newInt32,
+  newInt64,
+  newFloat32,
+  newFloat64,
+} from "runtime/dataStructures"
+
+@unsafe
 export let toInt32 = n => {
-  let ptr = Memory.malloc(12n)
-  WasmI32.store(ptr, Tags._GRAIN_BOXED_NUM_HEAP_TAG, 0n)
-  WasmI32.store(ptr, Tags._GRAIN_INT32_BOXED_NUM_TAG, 4n)
-  WasmI32.store(ptr, n, 8n)
-
-  WasmI32.toGrain(ptr): Int32
+  WasmI32.toGrain(newInt32(n)): Int32
 }
 
-@disableGC
+@unsafe
 export let fromInt32 = (n: Int32) => {
   let ptr = WasmI32.fromGrain(n)
   WasmI32.load(ptr, 8n)
 }
 
-@disableGC
+@unsafe
 export let toInt64 = n => {
-  let ptr = Memory.malloc(16n)
-  WasmI32.store(ptr, Tags._GRAIN_BOXED_NUM_HEAP_TAG, 0n)
-  WasmI32.store(ptr, Tags._GRAIN_INT64_BOXED_NUM_TAG, 4n)
-  WasmI64.store(ptr, n, 8n)
-
-  WasmI32.toGrain(ptr): Int64
+  WasmI32.toGrain(newInt64(n)): Int64
 }
 
-@disableGC
+@unsafe
 export let fromInt64 = (n: Int64) => {
   let ptr = WasmI32.fromGrain(n)
   WasmI64.load(ptr, 8n)
 }
 
-@disableGC
+@unsafe
 export let toFloat32 = n => {
-  let ptr = Memory.malloc(12n)
-  WasmI32.store(ptr, Tags._GRAIN_BOXED_NUM_HEAP_TAG, 0n)
-  WasmI32.store(ptr, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG, 4n)
-  WasmF32.store(ptr, n, 8n)
-
-  WasmI32.toGrain(ptr): Float32
+  WasmI32.toGrain(newFloat32(n)): Float32
 }
 
-@disableGC
+@unsafe
 export let fromFloat32 = (n: Float32) => {
   let ptr = WasmI32.fromGrain(n)
   WasmF32.load(ptr, 8n)
 }
 
-@disableGC
+@unsafe
 export let toFloat64 = n => {
-  let ptr = Memory.malloc(16n)
-  WasmI32.store(ptr, Tags._GRAIN_BOXED_NUM_HEAP_TAG, 0n)
-  WasmI32.store(ptr, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG, 4n)
-  WasmF64.store(ptr, n, 8n)
-
-  WasmI32.toGrain(ptr): Float64
+  WasmI32.toGrain(newFloat64(n)): Float64
 }
 
-@disableGC
+@unsafe
 export let fromFloat64 = (n: Float64) => {
   let ptr = WasmI32.fromGrain(n)
   WasmF64.load(ptr, 8n)
@@ -72,13 +56,10 @@ export let fromFloat64 = (n: Float64) => {
 /**
  * Converts a WasmI32 value to Number.
  * 
- * This function is meant to be called from a `@disableGC` context without
- * need to call incRef on the function.
- * 
  * @param n: The WasmI32 to convert
  * @returns The value converted to either a simple or a 32 bit heap allocated number.
  */
-@disableGC
+@unsafe
 export let wasmI32ToNumber = (n: WasmI32) => {
   // Follows a little optimization. Instead of testing if n is range of allowed
   // non heap allocated simple numbers (-1073741824n..1073741823n), actually
@@ -106,8 +87,7 @@ export let wasmI32ToNumber = (n: WasmI32) => {
     // If it did overflow, then the value differs and we need to discard it and
     // allocate the number on the heap. A boxed 32 bit number actually is the
     // same thing as an Int32. It only needs to be cast into Number.
-    let asInt32 = toInt32(n)
-    WasmI32.toGrain(WasmI32.fromGrain(asInt32)): Number
+    WasmI32.toGrain(newInt32(n)): Number
   }
   result
 }

package/runtime/unsafe/conv.md

@@ -54,9 +54,6 @@ wasmI32ToNumber : WasmI32 -> Number
 
 Converts a WasmI32 value to Number.
 
-This function is meant to be called from a `@disableGC` context without
-need to call incRef on the function.
-
 Parameters:
 
 |param|type|description|

package/runtime/unsafe/printWasm.gr

@@ -4,74 +4,38 @@ import Memory from "runtime/unsafe/memory"
 
 // [FIXME] These all leak ATM (grain-lang/grain#791)
 
-@disableGC
+@unsafe
 export let printI32 = val => {
-  Memory.incRef(WasmI32.fromGrain(print))
-  Memory.incRef(WasmI32.fromGrain(toString))
   let conv = Conv.toInt32(val)
-  Memory.incRef(WasmI32.fromGrain(conv))
-  Memory.incRef(WasmI32.fromGrain(toString))
   let s1 = toString(conv)
   let s2 = "n"
-  Memory.incRef(WasmI32.fromGrain(s1))
-  Memory.incRef(WasmI32.fromGrain(s2))
-  Memory.incRef(WasmI32.fromGrain((++)))
   let s = s1 ++ s2
-  Memory.incRef(WasmI32.fromGrain(print))
-  Memory.incRef(WasmI32.fromGrain(s))
   print(s)
 }
 
-@disableGC
+@unsafe
 export let printI64 = val => {
-  Memory.incRef(WasmI32.fromGrain(print))
-  Memory.incRef(WasmI32.fromGrain(toString))
   let conv = Conv.toInt64(val)
-  Memory.incRef(WasmI32.fromGrain(conv))
-  Memory.incRef(WasmI32.fromGrain(toString))
   let s1 = toString(conv)
   let s2 = "N"
-  Memory.incRef(WasmI32.fromGrain(s1))
-  Memory.incRef(WasmI32.fromGrain(s2))
-  Memory.incRef(WasmI32.fromGrain((++)))
   let s = s1 ++ s2
-  Memory.incRef(WasmI32.fromGrain(print))
-  Memory.incRef(WasmI32.fromGrain(s))
   print(s)
 }
 
-@disableGC
+@unsafe
 export let printF32 = val => {
-  Memory.incRef(WasmI32.fromGrain(print))
-  Memory.incRef(WasmI32.fromGrain(toString))
   let conv = Conv.toFloat32(val)
-  Memory.incRef(WasmI32.fromGrain(conv))
-  Memory.incRef(WasmI32.fromGrain(toString))
   let s1 = toString(conv)
   let s2 = "w"
-  Memory.incRef(WasmI32.fromGrain(s1))
-  Memory.incRef(WasmI32.fromGrain(s2))
-  Memory.incRef(WasmI32.fromGrain((++)))
   let s = s1 ++ s2
-  Memory.incRef(WasmI32.fromGrain(print))
-  Memory.incRef(WasmI32.fromGrain(s))
   print(s)
 }
 
-@disableGC
+@unsafe
 export let printF64 = val => {
-  Memory.incRef(WasmI32.fromGrain(print))
-  Memory.incRef(WasmI32.fromGrain(toString))
   let conv = Conv.toFloat64(val)
-  Memory.incRef(WasmI32.fromGrain(conv))
-  Memory.incRef(WasmI32.fromGrain(toString))
   let s1 = toString(conv)
   let s2 = "W"
-  Memory.incRef(WasmI32.fromGrain(s1))
-  Memory.incRef(WasmI32.fromGrain(s2))
-  Memory.incRef(WasmI32.fromGrain((++)))
   let s = s1 ++ s2
-  Memory.incRef(WasmI32.fromGrain(print))
-  Memory.incRef(WasmI32.fromGrain(s))
   print(s)
 }

package/runtime/utils/printing.gr

@@ -12,12 +12,12 @@ import foreign wasm fd_write: (
 ) -> WasmI32 from "wasi_snapshot_preview1"
 
 @unsafe
-export let rec numberToString = (n: WasmI64) => {
+export let numberToString = (n: WasmI64) => {
   NumberUtils.itoa64(n, 10n)
 }
 
 @unsafe
-export let rec printNumber = (n: WasmI64) => {
+export let printNumber = (n: WasmI64) => {
   // like print(), but `s` should be a Grain string
   let (+) = WasmI32.add
   let s = numberToString(n)
@@ -40,7 +40,7 @@ export let rec printNumber = (n: WasmI64) => {
 }
 
 @unsafe
-export let rec printString = (s: String) => {
+export let printString = (s: String) => {
   // like print(), but `s` should be a Grain string
   let (+) = WasmI32.add
   let ptr = WasmI32.fromGrain(s)