@grain/stdlib 0.4.6 → 0.5.0

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)
 }