@grain/stdlib 0.4.4 → 0.5.0

package/int64.gr

@@ -1,132 +1,215 @@
+/**
+ * @module Int64: Utilities for working with the Int64 type.
+ * @example import Int64 from "int64"
+ * 
+ * @since v0.2.0
+ */
 import WasmI32 from "runtime/unsafe/wasmi32"
 import WasmI64 from "runtime/unsafe/wasmi64"
 import Exception from "runtime/exception"
-import Memory from "runtime/unsafe/memory"
 
-import {
-  newInt64
-} from "runtime/dataStructures"
+import { newInt64 } from "runtime/dataStructures"
 
 import {
   coerceNumberToInt64 as fromNumber,
-  coerceInt64ToNumber as toNumber
+  coerceInt64ToNumber as toNumber,
 } from "runtime/numbers"
 
+/**
+ * @section Conversions: Functions for converting between Numbers and the Int64 type.
+ */
+
+/**
+ * Converts a Number to an Int64.
+ *
+ * @param number: The value to convert
+ * @returns The Number represented as an Int64
+ * 
+ * @since v0.2.0
+ */
 export fromNumber
+
+/**
+ * Converts an Int64 to a Number.
+ *
+ * @param value: The value to convert
+ * @returns The Int64 represented as a Number
+ * 
+ * @since v0.2.0
+ */
 export toNumber
 
-@disableGC
-export let rec incr = (n: Int64) => {
-  let n = WasmI32.fromGrain(n)
-  let ptr = newInt64(WasmI64.add(WasmI64.load(n, 8n), 1N))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(n)
-  Memory.decRef(WasmI32.fromGrain(incr))
-  ret
+/**
+ * @section Operations: Mathematical operations for Int64 values.
+ */
+
+/**
+ * Increments the value by one.
+ *
+ * @param value: The value to increment
+ * @returns The incremented value
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let incr = (value: Int64) => {
+  let value = WasmI32.fromGrain(value)
+  let ptr = newInt64(WasmI64.add(WasmI64.load(value, 8n), 1N))
+  WasmI32.toGrain(ptr): Int64
 }
 
-@disableGC
-export let decr = (n: Int64) => {
-  let n = WasmI32.fromGrain(n)
-  let ptr = newInt64(WasmI64.sub(WasmI64.load(n, 8n), 1N))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(n)
-  Memory.decRef(WasmI32.fromGrain(decr))
-  ret
+/**
+ * Decrements the value by one.
+ *
+ * @param value: The value to decrement
+ * @returns The decremented value
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let decr = (value: Int64) => {
+  let value = WasmI32.fromGrain(value)
+  let ptr = newInt64(WasmI64.sub(WasmI64.load(value, 8n), 1N))
+  WasmI32.toGrain(ptr): Int64
 }
 
-@disableGC
-export let rec add = (x: Int64, y: Int64) => {
+/**
+ * Computes the sum of its operands.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns The sum of the two operands
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let add = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
   let ptr = newInt64(WasmI64.add(xv, yv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(add))
-  ret
+  WasmI32.toGrain(ptr): Int64
 }
 
-@disableGC
-export let rec sub = (x: Int64, y: Int64) => {
+/**
+ * Computes the difference of its operands.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns The difference of the two operands
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let sub = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
   let ptr = newInt64(WasmI64.sub(xv, yv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(sub))
-  ret
+  WasmI32.toGrain(ptr): Int64
 }
 
-@disableGC
-export let rec mul = (x: Int64, y: Int64) => {
+/**
+ * Computes the product of its operands.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns The product of the two operands
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let mul = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
   let ptr = newInt64(WasmI64.mul(xv, yv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(mul))
-  ret
+  WasmI32.toGrain(ptr): Int64
 }
 
-@disableGC
-export let rec div = (x: Int64, y: Int64) => {
+/**
+ * Computes the quotient of its operands using signed division.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns The quotient of its operands
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let div = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
   let ptr = newInt64(WasmI64.divS(xv, yv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(div))
-  ret
+  WasmI32.toGrain(ptr): Int64
 }
 
-@disableGC
-export let rec divU = (x: Int64, y: Int64) => {
+/**
+ * Computes the quotient of its operands using unsigned division.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns The quotient of its operands
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let divU = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
   let ptr = newInt64(WasmI64.divU(xv, yv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(divU))
-  ret
+  WasmI32.toGrain(ptr): Int64
 }
 
-@disableGC
-export let rec rem = (x: Int64, y: Int64) => {
+/**
+ * Computes the remainder of the division of its operands using signed division.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns The remainder of its operands
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let rem = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
   let ptr = newInt64(WasmI64.remS(xv, yv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(rem))
-  ret
+  WasmI32.toGrain(ptr): Int64
 }
 
-@disableGC
-export let rec remU = (x: Int64, y: Int64) => {
+/**
+ * Computes the remainder of the division of its operands using unsigned division.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns The remainder of its operands
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let remU = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
   let ptr = newInt64(WasmI64.remU(xv, yv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(remU))
-  ret
+  WasmI32.toGrain(ptr): Int64
 }
 
-@disableGC
-let abs = (n) => {
+@unsafe
+let abs = n => {
   let mask = WasmI64.shrS(n, 63N)
   WasmI64.sub(WasmI64.xor(n, mask), mask)
 }
 
-@disableGC
-export let rec mod = (x: Int64, y: Int64) => {
+/**
+ * Computes the remainder of the division of the first operand by the second. 
+ * The result will have the sign of the second operand.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns The modulus of its operands
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let mod = (x: Int64, y: Int64) => {
   let xval = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yval = WasmI64.load(WasmI32.fromGrain(y), 8n)
 
@@ -139,229 +222,395 @@ export let rec mod = (x: Int64, y: Int64) => {
     let yabs = abs(yval)
     let mval = WasmI64.remS(xabs, yabs)
     let mres = WasmI64.sub(yabs, mval)
-    newInt64(if (WasmI64.ne(mval, 0N)) (if (WasmI64.ltS(yval, 0N)) WasmI64.sub(0N, mres) else mres) else 0N)
+    newInt64(
+      if (WasmI64.ne(mval, 0N)) (
+        if (WasmI64.ltS(yval, 0N)) WasmI64.sub(0N, mres) else mres
+      ) else 0N
+    )
   } else {
     newInt64(WasmI64.remS(xval, yval))
   }
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(mod))
-  ret
+  WasmI32.toGrain(ptr): Int64
 }
 
-@disableGC
-export let rec clz = (n: Int64) => {
-  let nv = WasmI64.load(WasmI32.fromGrain(n), 8n)
-  let ptr = newInt64(WasmI64.clz(nv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(n))
-  Memory.decRef(WasmI32.fromGrain(clz))
-  ret
+/**
+ * @section Bitwise operations: Functions for operating on bits of Int64 values.
+ */
+
+/**
+ * Rotates the bits of the value left by the given number of bits.
+ *
+ * @param value: The value to rotate
+ * @param amount: The number of bits to rotate by
+ * @returns The rotated value
+ * 
+ * @since v0.4.0
+ */
+@unsafe
+export let rotl = (value: Int64, amount: Int64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(value), 8n)
+  let yv = WasmI64.load(WasmI32.fromGrain(amount), 8n)
+  let ptr = newInt64(WasmI64.rotl(xv, yv))
+  WasmI32.toGrain(ptr): Int64
 }
 
-@disableGC
-export let rec ctz = (n: Int64) => {
-  let nv = WasmI64.load(WasmI32.fromGrain(n), 8n)
-  let ptr = newInt64(WasmI64.ctz(nv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(n))
-  Memory.decRef(WasmI32.fromGrain(ctz))
-  ret
+/**
+ * Rotates the bits of the value right by the given number of bits.
+ *
+ * @param value: The value to rotate
+ * @param amount: The number of bits to rotate by
+ * @returns The rotated value
+ * 
+ * @since v0.4.0
+ */
+@unsafe
+export let rotr = (value: Int64, amount: Int64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(value), 8n)
+  let yv = WasmI64.load(WasmI32.fromGrain(amount), 8n)
+  let ptr = newInt64(WasmI64.rotr(xv, yv))
+  WasmI32.toGrain(ptr): Int64
 }
 
-@disableGC
-export let rec popcnt = (n: Int64) => {
-  let nv = WasmI64.load(WasmI32.fromGrain(n), 8n)
-  let ptr = newInt64(WasmI64.popcnt(nv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(n))
-  Memory.decRef(WasmI32.fromGrain(popcnt))
-  ret
+/**
+ * Shifts the bits of the value left by the given number of bits.
+ *
+ * @param value: The value to shift
+ * @param amount: The number of bits to shift by
+ * @returns The shifted value
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let shl = (value: Int64, amount: Int64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(value), 8n)
+  let yv = WasmI64.load(WasmI32.fromGrain(amount), 8n)
+  let ptr = newInt64(WasmI64.shl(xv, yv))
+  WasmI32.toGrain(ptr): Int64
+}
+
+/**
+ * Shifts the bits of the value right by the given number of bits, preserving the sign bit.
+ *
+ * @param value: The value to shift
+ * @param amount: The amount to shift by
+ * @returns The shifted value
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let shr = (value: Int64, amount: Int64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(value), 8n)
+  let yv = WasmI64.load(WasmI32.fromGrain(amount), 8n)
+  let ptr = newInt64(WasmI64.shrS(xv, yv))
+  WasmI32.toGrain(ptr): Int64
+}
+
+/**
+ * Shifts the bits of the value right by the given number of bits.
+ *
+ * @param value: The value to shift
+ * @param amount: The amount to shift by
+ * @returns The shifted value
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let shrU = (value: Int64, amount: Int64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(value), 8n)
+  let yv = WasmI64.load(WasmI32.fromGrain(amount), 8n)
+  let ptr = newInt64(WasmI64.shrU(xv, yv))
+  WasmI32.toGrain(ptr): Int64
 }
 
-@disableGC
-export let rec rotl = (x: Int64, y: Int64) => {
+/**
+ * @section Comparisons: Functions for comparing Int64 values.
+ */
+
+/**
+ * Checks if the first value is equal to the second value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is equal to the second value or `false` otherwise
+ * 
+ * @since v0.4.0
+ */
+@unsafe
+export let eq = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
-  let ptr = newInt64(WasmI64.rotl(xv, yv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(rotl))
-  ret
+  WasmI64.eq(xv, yv)
 }
 
-@disableGC
-export let rec rotr = (x: Int64, y: Int64) => {
+/**
+ * Checks if the first value is not equal to the second value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is not equal to the second value or `false` otherwise
+ * 
+ * @since v0.4.0
+ */
+@unsafe
+export let ne = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
-  let ptr = newInt64(WasmI64.rotr(xv, yv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(rotr))
-  ret
+  WasmI64.ne(xv, yv)
 }
 
-// Int64 comparisons
+/**
+ * Checks if the given value is equal to zero.
+ *
+ * @param value: The value to inspect
+ * @returns `true` if the first value is equal to zero or `false` otherwise
+ * 
+ * @since v0.4.0
+ */
+@unsafe
+export let eqz = (value: Int64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(value), 8n)
+  WasmI64.eqz(xv)
+}
 
-@disableGC
-export let rec eq = (x: Int64, y: Int64) => {
+/**
+ * Checks if the first value is less than the second value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is less than the second value or `false` otherwise
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let lt = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
-  let ret = WasmI64.eq(xv, yv)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(eq))
-  ret
+  WasmI64.ltS(xv, yv)
 }
 
-@disableGC
-export let rec ne = (x: Int64, y: Int64) => {
+/**
+ * Checks if the first unsigned value is less than the second unsigned value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is less than the second value or `false` otherwise
+ *
+ * @since v0.5.0
+ */
+@unsafe
+export let rec ltU = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
-  let ret = WasmI64.ne(xv, yv)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(ne))
-  ret
+  WasmI64.ltU(xv, yv)
 }
 
-@disableGC
-export let rec eqz = (n: Int64) => {
-  let xv = WasmI64.load(WasmI32.fromGrain(n), 8n)
-  let ret = WasmI64.eqz(xv)
-  Memory.decRef(WasmI32.fromGrain(n))
-  Memory.decRef(WasmI32.fromGrain(eqz))
-  ret
+/**
+ * Checks if the first value is greater than the second value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is greater than the second value or `false` otherwise
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let gt = (x: Int64, y: Int64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
+  let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
+  WasmI64.gtS(xv, yv)
 }
 
-@disableGC
-export let rec lt = (x: Int64, y: Int64) => {
+/**
+ * Checks if the first unsigned value is greater than the second unsigned value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is greater than the second value or `false` otherwise
+ *
+ * @since v0.5.0
+ */
+@unsafe
+export let rec gtU = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
-  let ret = WasmI64.ltS(xv, yv)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(lt))
-  ret
+  WasmI64.gtU(xv, yv)
 }
 
-@disableGC
-export let rec gt = (x: Int64, y: Int64) => {
+/**
+ * Checks if the first value is less than or equal to the second value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is less than or equal to the second value or `false` otherwise
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let lte = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
-  let ret = WasmI64.gtS(xv, yv)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(gt))
-  ret
+  WasmI64.leS(xv, yv)
 }
 
-@disableGC
-export let rec lte = (x: Int64, y: Int64) => {
+/**
+ * Checks if the first unsigned value is less than or equal to the second unsigned value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is less than or equal to the second value or `false` otherwise
+ *
+ * @since v0.5.0
+ */
+@unsafe
+export let rec lteU = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
-  let ret = WasmI64.leS(xv, yv)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(lte))
-  ret
+  WasmI64.leU(xv, yv)
 }
 
-@disableGC
-export let rec gte = (x: Int64, y: Int64) => {
+/**
+ * Checks if the first value is greater than or equal to the second value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is greater than or equal to the second value or `false` otherwise
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let gte = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
-  let ret = WasmI64.geS(xv, yv)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(gte))
-  ret
+  WasmI64.geS(xv, yv)
 }
 
-// Int64 bit/logical operations
-@disableGC
-export let rec lnot = (x: Int64) => {
+/**
+ * Checks if the first unsigned value is greater than or equal to the second unsigned value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is greater than or equal to the second value or `false` otherwise
+ *
+ * @since v0.5.0
+ */
+@unsafe
+export let rec gteU = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
-  let ptr = newInt64(WasmI64.xor(xv, 0xffffffffffffffffN))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(lnot))
-  ret
+  let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
+  WasmI64.geU(xv, yv)
 }
 
+/**
+ * @section Bitwise logic: Boolean operations on the bits of Int64 values.
+ */
+
+/**
+ * Computes the bitwise NOT of the given value.
+ *
+ * @param value: The given value
+ * @returns Containing the inverted bits of the given value
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let lnot = (value: Int64) => {
+  let xv = WasmI64.load(WasmI32.fromGrain(value), 8n)
+  let ptr = newInt64(WasmI64.xor(xv, 0xffffffffffffffffN))
+  WasmI32.toGrain(ptr): Int64
+}
 
-@disableGC
-export let rec land = (x: Int64, y: Int64) => {
+/**
+ * Computes the bitwise AND (`&`) on the given operands.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns Containing a `1` in each bit position for which the corresponding bits of both operands are `1`
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let land = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
   let ptr = newInt64(WasmI64.and(xv, yv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(land))
-  ret
+  WasmI32.toGrain(ptr): Int64
 }
 
-@disableGC
-export let rec lor = (x: Int64, y: Int64) => {
+/**
+ * Computes the bitwise OR (`|`) on the given operands.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns Containing a `1` in each bit position for which the corresponding bits of either or both operands are `1`
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let lor = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
   let ptr = newInt64(WasmI64.or(xv, yv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(lor))
-  ret
+  WasmI32.toGrain(ptr): Int64
 }
 
-@disableGC
-export let rec lxor = (x: Int64, y: Int64) => {
+/**
+ * Computes the bitwise XOR (`^`) on the given operands.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns Containing a `1` in each bit position for which the corresponding bits of either but not both operands are `1`
+ * 
+ * @since v0.2.0
+ */
+@unsafe
+export let lxor = (x: Int64, y: Int64) => {
   let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
   let ptr = newInt64(WasmI64.xor(xv, yv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(lxor))
-  ret
+  WasmI32.toGrain(ptr): Int64
 }
 
-
-@disableGC
-export let rec shl = (x: Int64, y: Int64) => {
-  let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
-  let ptr = newInt64(WasmI64.shl(xv, yv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(shl))
-  ret
+/**
+ * Counts the number of leading zero bits in the value.
+ *
+ * @param value: The value to inspect
+ * @returns The amount of leading zeros
+ * 
+ * @since v0.4.0
+ */
+@unsafe
+export let clz = (value: Int64) => {
+  let nv = WasmI64.load(WasmI32.fromGrain(value), 8n)
+  let ptr = newInt64(WasmI64.clz(nv))
+  WasmI32.toGrain(ptr): Int64
 }
 
-@disableGC
-export let rec shr = (x: Int64, y: Int64) => {
-  let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
-  let ptr = newInt64(WasmI64.shrS(xv, yv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(shr))
-  ret
+/**
+ * Counts the number of trailing zero bits in the value.
+ *
+ * @param value: The value to inspect
+ * @returns The amount of trailing zeros
+ * 
+ * @since v0.4.0
+ */
+@unsafe
+export let ctz = (value: Int64) => {
+  let nv = WasmI64.load(WasmI32.fromGrain(value), 8n)
+  let ptr = newInt64(WasmI64.ctz(nv))
+  WasmI32.toGrain(ptr): Int64
 }
 
-@disableGC
-export let rec shrU = (x: Int64, y: Int64) => {
-  let xv = WasmI64.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI64.load(WasmI32.fromGrain(y), 8n)
-  let ptr = newInt64(WasmI64.shrU(xv, yv))
-  let ret = WasmI32.toGrain(ptr): Int64
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(shrU))
-  ret
+/**
+ * Counts the number of bits set to `1` in the value, also known as a population count.
+ *
+ * @param value: The value to inspect
+ * @returns The amount of 1-bits in its operand
+ * 
+ * @since v0.4.0
+ */
+@unsafe
+export let popcnt = (value: Int64) => {
+  let nv = WasmI64.load(WasmI32.fromGrain(value), 8n)
+  let ptr = newInt64(WasmI64.popcnt(nv))
+  WasmI32.toGrain(ptr): Int64
 }