@grain/stdlib 0.4.6 → 0.5.2

package/float64.gr

@@ -6,16 +6,68 @@
  */
 import WasmI32 from "runtime/unsafe/wasmi32"
 import WasmF64 from "runtime/unsafe/wasmf64"
-import Memory from "runtime/unsafe/memory"
-import {
-  newFloat64
-} from "runtime/dataStructures"
+import { newFloat64 } from "runtime/dataStructures"
 
 import {
   coerceNumberToFloat64 as fromNumber,
-  coerceFloat64ToNumber as toNumber
+  coerceFloat64ToNumber as toNumber,
 } from "runtime/numbers"
 
+/**
+ * @section Constants: Float64 constant values.
+ */
+
+/**
+ * Infinity represented as a Float64 value.
+ * 
+ * @since v0.4.0
+ */
+@unsafe
+export let infinity = {
+  let ptr = newFloat64(
+    WasmF64.reinterpretI64(
+      0b0111111111110000000000000000000000000000000000000000000000000000N
+    )
+  )
+  WasmI32.toGrain(ptr): Float64
+}
+
+/**
+ * NaN (Not a Number) represented as a Float64 value.
+ * 
+ * @since v0.4.0
+ */
+@unsafe
+export let nan = {
+  let ptr = newFloat64(
+    WasmF64.reinterpretI64(
+      0b0111111111110000000000000000000000000000000000000000000000000001N
+    )
+  )
+  WasmI32.toGrain(ptr): Float64
+}
+
+/**
+ * Pi represented as a Float64 value.
+ * 
+ * @since v0.5.2
+ */
+export let pi = 3.141592653589793d
+
+/**
+ * Tau represented as a Float64 value.
+ * 
+ * @since v0.5.2
+ */
+export let tau = 6.283185307179586d
+
+/**
+ * Euler's number represented as a Float64 value.
+ * 
+ * @since v0.5.2
+ */
+export let e = 2.718281828459045d
+
 /**
  * @section Conversions: Functions for converting between Numbers and the Float64 type.
  */
@@ -53,16 +105,12 @@ export toNumber
  * 
  * @since v0.2.0
  */
-@disableGC
-export let rec add = (x: Float64, y: Float64) => {
+@unsafe
+export let add = (x: Float64, y: Float64) => {
   let xv = WasmF64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmF64.load(WasmI32.fromGrain(y), 8n)
   let ptr = newFloat64(WasmF64.add(xv, yv))
-  let ret = WasmI32.toGrain(ptr) : Float64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(add))
-  ret
+  WasmI32.toGrain(ptr): Float64
 }
 
 /**
@@ -74,16 +122,12 @@ export let rec add = (x: Float64, y: Float64) => {
  * 
  * @since v0.2.0
  */
-@disableGC
-export let rec sub = (x: Float64, y: Float64) => {
+@unsafe
+export let sub = (x: Float64, y: Float64) => {
   let xv = WasmF64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmF64.load(WasmI32.fromGrain(y), 8n)
   let ptr = newFloat64(WasmF64.sub(xv, yv))
-  let ret = WasmI32.toGrain(ptr) : Float64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(sub))
-  ret
+  WasmI32.toGrain(ptr): Float64
 }
 
 /**
@@ -95,16 +139,12 @@ export let rec sub = (x: Float64, y: Float64) => {
  * 
  * @since v0.2.0
  */
-@disableGC
-export let rec mul = (x: Float64, y: Float64) => {
+@unsafe
+export let mul = (x: Float64, y: Float64) => {
   let xv = WasmF64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmF64.load(WasmI32.fromGrain(y), 8n)
   let ptr = newFloat64(WasmF64.mul(xv, yv))
-  let ret = WasmI32.toGrain(ptr) : Float64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(mul))
-  ret
+  WasmI32.toGrain(ptr): Float64
 }
 
 /**
@@ -116,16 +156,12 @@ export let rec mul = (x: Float64, y: Float64) => {
  * 
  * @since v0.2.0
  */
-@disableGC
-export let rec div = (x: Float64, y: Float64) => {
+@unsafe
+export let div = (x: Float64, y: Float64) => {
   let xv = WasmF64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmF64.load(WasmI32.fromGrain(y), 8n)
   let ptr = newFloat64(WasmF64.div(xv, yv))
-  let ret = WasmI32.toGrain(ptr) : Float64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(div))
-  ret
+  WasmI32.toGrain(ptr): Float64
 }
 
 /**
@@ -141,15 +177,11 @@ export let rec div = (x: Float64, y: Float64) => {
  * 
  * @since v0.2.0
  */
-@disableGC
-export let rec lt = (x: Float64, y: Float64) => {
+@unsafe
+export let lt = (x: Float64, y: Float64) => {
   let xv = WasmF64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmF64.load(WasmI32.fromGrain(y), 8n)
-  let ret = WasmF64.lt(xv, yv)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(lt))
-  ret
+  WasmF64.lt(xv, yv)
 }
 
 /**
@@ -161,15 +193,11 @@ export let rec lt = (x: Float64, y: Float64) => {
  * 
  * @since v0.2.0
  */
-@disableGC
-export let rec gt = (x: Float64, y: Float64) => {
+@unsafe
+export let gt = (x: Float64, y: Float64) => {
   let xv = WasmF64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmF64.load(WasmI32.fromGrain(y), 8n)
-  let ret = WasmF64.gt(xv, yv)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(gt))
-  ret
+  WasmF64.gt(xv, yv)
 }
 
 /**
@@ -181,15 +209,11 @@ export let rec gt = (x: Float64, y: Float64) => {
  * 
  * @since v0.2.0
  */
-@disableGC
-export let rec lte = (x: Float64, y: Float64) => {
+@unsafe
+export let lte = (x: Float64, y: Float64) => {
   let xv = WasmF64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmF64.load(WasmI32.fromGrain(y), 8n)
-  let ret = WasmF64.le(xv, yv)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(lte))
-  ret
+  WasmF64.le(xv, yv)
 }
 
 /**
@@ -201,47 +225,9 @@ export let rec lte = (x: Float64, y: Float64) => {
  * 
  * @since v0.2.0
  */
-@disableGC
-export let rec gte = (x: Float64, y: Float64) => {
+@unsafe
+export let gte = (x: Float64, y: Float64) => {
   let xv = WasmF64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmF64.load(WasmI32.fromGrain(y), 8n)
-  let ret = WasmF64.ge(xv, yv)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(gte))
-  ret
+  WasmF64.ge(xv, yv)
 }
-
-/**
- * @section Constants: Float64 constant values.
- */
-
-@disableGC
-let rec makeInfinity = () => {
-  let ptr = newFloat64(WasmF64.reinterpretI64(0b0111111111110000000000000000000000000000000000000000000000000000N))
-  let ret = WasmI32.toGrain(ptr) : Float64
-  Memory.decRef(WasmI32.fromGrain(makeInfinity))
-  ret
-}
-
-/**
- * Infinity represented as a Float64 value.
- * 
- * @since v0.4.0
- */
-export let infinity = makeInfinity()
-
-@disableGC
-let rec makeNaN = () => {
-  let ptr = newFloat64(WasmF64.reinterpretI64(0b0111111111110000000000000000000000000000000000000000000000000001N))
-  let ret = WasmI32.toGrain(ptr) : Float64
-  Memory.decRef(WasmI32.fromGrain(makeNaN))
-  ret
-}
-
-/**
- * NaN (Not a Number) represented as a Float64 value.
- * 
- * @since v0.4.0
- */
-export let nan = makeNaN()

package/float64.md

@@ -13,6 +13,75 @@ No other changes yet.
 import Float64 from "float64"
 ```
 
+## Constants
+
+Float64 constant values.
+
+### Float64.**infinity**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.4.0</code></summary>
+No other changes yet.
+</details>
+
+```grain
+infinity : Float64
+```
+
+Infinity represented as a Float64 value.
+
+### Float64.**nan**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.4.0</code></summary>
+No other changes yet.
+</details>
+
+```grain
+nan : Float64
+```
+
+NaN (Not a Number) represented as a Float64 value.
+
+### Float64.**pi**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+pi : Float64
+```
+
+Pi represented as a Float64 value.
+
+### Float64.**tau**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+tau : Float64
+```
+
+Tau represented as a Float64 value.
+
+### Float64.**e**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+e : Float64
+```
+
+Euler's number represented as a Float64 value.
+
 ## Conversions
 
 Functions for converting between Numbers and the Float64 type.
@@ -283,33 +352,3 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is greater than or equal to the second value or `false` otherwise|
 
-## Constants
-
-Float64 constant values.
-
-### Float64.**infinity**
-
-<details disabled>
-<summary tabindex="-1">Added in <code>0.4.0</code></summary>
-No other changes yet.
-</details>
-
-```grain
-infinity : Float64
-```
-
-Infinity represented as a Float64 value.
-
-### Float64.**nan**
-
-<details disabled>
-<summary tabindex="-1">Added in <code>0.4.0</code></summary>
-No other changes yet.
-</details>
-
-```grain
-nan : Float64
-```
-
-NaN (Not a Number) represented as a Float64 value.
-

package/hash.gr

@@ -1,5 +1,3 @@
-/* grainc-flags --no-gc */
-
 /**
  * @module Hash: Utilities for hashing any value.
  * @example import Hash from "hash"
@@ -27,34 +25,42 @@ import WasmI32, {
   gtU as (>),
   ltU as (<),
 } from "runtime/unsafe/wasmi32"
+import WasmI64 from "runtime/unsafe/wasmi64"
 import Tags from "runtime/unsafe/tags"
-import Memory from "runtime/unsafe/memory"
 
 import { tagSimpleNumber } from "runtime/dataStructures"
 import { coerceNumberToWasmI32 } from "runtime/numbers"
+import BI from "runtime/bigint"
 
 import Random from "sys/random"
 import Result from "result"
 
+@unsafe
 let seed = {
-  Memory.incRef(WasmI32.fromGrain(Random.random))
-  Memory.incRef(WasmI32.fromGrain(Result.unwrap))
   let random = Random.random()
-  Memory.incRef(WasmI32.fromGrain(random))
   coerceNumberToWasmI32(Result.unwrap(random))
 }
 
+@unsafe
 let _MAX_HASH_DEPTH = 31n
 
+@unsafe
 let c1 = 0xcc9e2d51n
+@unsafe
 let c2 = 0x1b873593n
+@unsafe
 let r1 = 15n
+@unsafe
 let r2 = 13n
+@unsafe
 let m = 5n
+@unsafe
 let n = 0xe6546b64n
 
+@unsafe
 let mut h = seed
 
+@unsafe
 let hash32 = k => {
   let mut k = k * c1
   k = WasmI32.rotl(k, r1)
@@ -65,6 +71,14 @@ let hash32 = k => {
   h = h * m + n
 }
 
+@unsafe
+let hash64 = k => {
+  // convenience function for hashing 64-bit values
+  hash32(WasmI32.wrapI64(k))
+  hash32(WasmI32.wrapI64(WasmI64.shrU(k, 32N)))
+}
+
+@unsafe
 let hashRemaining = r => {
   // Note: wasm is little-endian so no swap is necessary
 
@@ -75,6 +89,7 @@ let hashRemaining = r => {
   h = h ^ r
 }
 
+@unsafe
 let finalize = len => {
   h = h ^ len
 
@@ -85,6 +100,7 @@ let finalize = len => {
   h = h ^ h >>> 16n
 }
 
+@unsafe
 let rec hashOne = (val, depth) => {
   if (depth > _MAX_HASH_DEPTH) {
     void
@@ -112,22 +128,6 @@ let rec hashOne = (val, depth) => {
         if (rem != 0n) hashRemaining(rem)
         finalize(length)
       },
-      t when t == Tags._GRAIN_CHAR_HEAP_TAG => {
-        let word = WasmI32.load(heapPtr, 4n)
-        // little-endian byte order
-        let byte = word & 0xFFn
-        let mut shift = 0n
-        if ((byte & 0x80n) == 0x00n) {
-          shift = 24n
-        } else if ((byte & 0xF0n) == 0xF0n) {
-          shift = 0n
-        } else if ((byte & 0xE0n) == 0xE0n) {
-          shift = 8n
-        } else {
-          shift = 16n
-        }
-        hash32(word << shift)
-      },
       t when t == Tags._GRAIN_ADT_HEAP_TAG => {
         // moduleId
         hash32(WasmI32.load(heapPtr, 4n))
@@ -189,6 +189,15 @@ let rec hashOne = (val, depth) => {
             hash32(WasmI32.load(heapPtr, 8n))
             hash32(WasmI32.load(heapPtr, 12n))
           },
+          t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => {
+            // TODO(#1187): should include fixint size once implemented
+            let size = BI.getSize(heapPtr)
+            hash32(size)
+            hash32(BI.getFlags(heapPtr))
+            for (let mut i = 0n; i < size; i += 1n) {
+              hash64(BI.getLimb(heapPtr, i))
+            }
+          },
           t when t == Tags._GRAIN_FLOAT32_BOXED_NUM_TAG => {
             hash32(WasmI32.load(heapPtr, 8n))
           },
@@ -197,8 +206,8 @@ let rec hashOne = (val, depth) => {
             hash32(WasmI32.load(heapPtr, 12n))
           },
           t when t == Tags._GRAIN_RATIONAL_BOXED_NUM_TAG => {
-            hash32(WasmI32.load(heapPtr, 8n))
-            hash32(WasmI32.load(heapPtr, 12n))
+            hashOne(WasmI32.load(heapPtr, 8n), depth + 1n)
+            hashOne(WasmI32.load(heapPtr, 12n), depth + 1n)
           },
           _ => {
             hash32(heapPtr)
@@ -209,13 +218,8 @@ let rec hashOne = (val, depth) => {
         hash32(heapPtr)
       },
     }
-  } else if (val == WasmI32.fromGrain(true)) {
-    hash32(val)
-  } else if (val == WasmI32.fromGrain(false)) {
-    hash32(val)
-  } else if (val == WasmI32.fromGrain(void)) {
-    hash32(val)
   } else {
+    // Handle non-heap values: booleans, chars, void, etc.
     hash32(val)
   }
 }
@@ -231,7 +235,8 @@ let rec hashOne = (val, depth) => {
  *
  * @since v0.1.0
  */
-export let rec hash = anything => {
+@unsafe
+export let hash = anything => {
   h = seed
 
   hashOne(WasmI32.fromGrain(anything), 0n)
@@ -239,10 +244,5 @@ export let rec hash = anything => {
 
   // Tag the number on the way out.
   // Since Grain has proper modulus, negative numbers are okay.
-  let result = tagSimpleNumber(h)
-
-  Memory.decRef(WasmI32.fromGrain(hash))
-  Memory.decRef(WasmI32.fromGrain(anything))
-
-  result
+  tagSimpleNumber(h)
 }