@grain/stdlib 0.4.4 → 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"
@@ -25,47 +23,63 @@ import WasmI32, {
   eq as (==),
   ne as (!=),
   gtU as (>),
-  ltU 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
 
-let hash32 = (k) => {
+@unsafe
+let hash32 = k => {
   let mut k = k * c1
   k = WasmI32.rotl(k, r1)
   k *= c2
 
   h = h ^ k
   h = WasmI32.rotl(h, r2)
-  h = (h * m) + n
+  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)))
 }
 
-let hashRemaining = (r) => {
+@unsafe
+let hashRemaining = r => {
   // Note: wasm is little-endian so no swap is necessary
 
   let mut r = r * c1
@@ -75,25 +89,31 @@ let hashRemaining = (r) => {
   h = h ^ r
 }
 
-let finalize = (len) => {
+@unsafe
+let finalize = len => {
   h = h ^ len
 
-  h = h ^ (h >>> 16n)
+  h = h ^ h >>> 16n
   h *= 0x85ebca6bn
-  h = h ^ (h >>> 13n)
+  h = h ^ h >>> 13n
   h *= 0xc2b2ae35n
-  h = h ^ (h >>> 16n)
+  h = h ^ h >>> 16n
 }
 
+@unsafe
 let rec hashOne = (val, depth) => {
   if (depth > _MAX_HASH_DEPTH) {
     void
   } else if ((val & Tags._GRAIN_NUMBER_TAG_MASK) != 0n) {
     hash32(val)
-  } else if ((val & Tags._GRAIN_GENERIC_TAG_MASK) == Tags._GRAIN_GENERIC_HEAP_TAG_TYPE) {
+  } else if (
+    (val & Tags._GRAIN_GENERIC_TAG_MASK) == Tags._GRAIN_GENERIC_HEAP_TAG_TYPE
+  ) {
     let heapPtr = val
     match (WasmI32.load(heapPtr, 0n)) {
-      t when t == Tags._GRAIN_STRING_HEAP_TAG || t == Tags._GRAIN_BYTES_HEAP_TAG => {
+      t when (
+        t == Tags._GRAIN_STRING_HEAP_TAG || t == Tags._GRAIN_BYTES_HEAP_TAG
+      ) => {
         let length = WasmI32.load(heapPtr, 4n)
         let extra = length % 4n
         let l = length - extra
@@ -108,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))
@@ -185,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))
           },
@@ -193,25 +206,20 @@ 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)
-          }
+          },
         }
       },
       _ => {
         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)
   }
 }
@@ -227,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)
@@ -235,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)
 }