@grain/stdlib 0.5.4 → 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

package/runtime/equal.gr

@@ -208,6 +208,6 @@ equalHelp = (x, y) => {
 }
 
 @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/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)
@@ -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

package/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))
         }
@@ -2220,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) &&
@@ -2239,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) &&
@@ -2257,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

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)

package/stack.gr

@@ -1,6 +1,8 @@
 /**
  * @module Stack: An immutable stack implementation. A stack is a LIFO (last-in-first-out) data structure where new values are added, retrieved, and removed from the end.
  * @example import Stack from "stack"
+ *
+ * @deprecated This module will be renamed to ImmutableStack in the v0.6.0 release of Grain.
  */
 
 import List from "list"
@@ -22,7 +24,7 @@ record Stack<a> {
 
 /**
  * An empty stack.
- * 
+ *
  * @since v0.5.4
  */
 export let empty = {
@@ -34,7 +36,7 @@ export let empty = {
  * Creates a new stack.
  *
  * @returns An empty stack
- * 
+ *
  * @deprecated This will be removed in the v0.6.0 release of Grain.
  */
 export let make = () => {

package/stack.md

@@ -2,6 +2,8 @@
 title: Stack
 ---
 
+> **Deprecated:** This module will be renamed to ImmutableStack in the v0.6.0 release of Grain.
+
 An immutable stack implementation. A stack is a LIFO (last-in-first-out) data structure where new values are added, retrieved, and removed from the end.
 
 ```grain

package/string.gr

@@ -221,7 +221,7 @@ export let lastIndexOf = (search: String, string: String) => {
   }
 }
 
-@disableGC
+@unsafe
 let getCodePoint = (ptr: WasmI32) => {
   // Algorithm from https://encoding.spec.whatwg.org/#utf-8-decoder
   let (+) = WasmI32.add

package/sys/time.gr

@@ -38,7 +38,7 @@ let getClockTime = (clockid, precision) => {
  * @returns `Ok(time)` of the current time if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let rec realTime = () => {
+export let realTime = () => {
   getClockTime(Wasi._CLOCK_REALTIME, 1000N)
 }
 
@@ -51,7 +51,7 @@ export let rec realTime = () => {
  * @returns `Ok(time)` of the current time if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let rec monotonicTime = () => {
+export let monotonicTime = () => {
   getClockTime(Wasi._CLOCK_MONOTONIC, 1N)
 }
 
@@ -61,7 +61,7 @@ export let rec monotonicTime = () => {
  * @returns `Ok(elapsed)` of the elapsed nanoseconds if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let rec processCpuTime = () => {
+export let processCpuTime = () => {
   getClockTime(Wasi._CLOCK_PROCESS_CPUTIME, 1N)
 }
 
@@ -71,6 +71,6 @@ export let rec processCpuTime = () => {
  * @returns `Ok(elapsed)` of the elapsed nanoseconds if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let rec threadCpuTime = () => {
+export let threadCpuTime = () => {
   getClockTime(Wasi._CLOCK_THREAD_CPUTIME, 1N)
 }