@grain/stdlib 0.5.12 → 0.6.0

package/int32.gr

@@ -1,46 +1,61 @@
 /**
- * @module Int32: Utilities for working with the Int32 type.
- * @example import Int32 from "int32"
+ * Utilities for working with the Int32 type.
+ *
+ * @example from "int32" include Int32
  *
  * @since v0.2.0
  */
-import WasmI32 from "runtime/unsafe/wasmi32"
-import Exception from "runtime/exception"
-
-import { newInt32 } from "runtime/dataStructures"
-
-import {
+module Int32
+
+from "runtime/unsafe/wasmi32" include WasmI32
+use WasmI32.{
+  (+),
+  (-),
+  (*),
+  (/),
+  (&),
+  (|),
+  (^),
+  (<<),
+  (>>),
+  (==),
+  (!=),
+  (<),
+  (<=),
+  (>),
+  (>=),
+}
+from "runtime/unsafe/wasmi64" include WasmI64
+from "runtime/exception" include Exception
+
+from "runtime/dataStructures" include DataStructures
+use DataStructures.{ newInt32 }
+
+from "runtime/numbers" include Numbers
+use Numbers.{
   coerceNumberToInt32 as fromNumber,
   coerceInt32ToNumber as toNumber,
-} from "runtime/numbers"
+}
 
-/**
- * @section Conversions: Functions for converting between Numbers and the Int32 type.
- */
+@unsafe
+let _VALUE_OFFSET = 4n
 
-/**
- * Converts a Number to an Int32.
- *
- * @param number: The value to convert
- * @returns The Number represented as an Int32
- *
- * @since v0.2.0
- */
-export fromNumber
+provide { fromNumber, toNumber }
 
 /**
- * Converts an Int32 to a Number.
+ * Converts a Uint32 to an Int32.
  *
- * @param value: The value to convert
- * @returns The Int32 represented as a Number
+ * @param number: The value to convert
+ * @returns The Uint32 represented as an Int32
  *
- * @since v0.2.0
- */
-export toNumber
-
-/**
- * @section Operations: Mathematical operations for Int32 values.
+ * @since v0.6.0
  */
+@unsafe
+provide let fromUint32 = (number: Uint32) => {
+  let x = WasmI32.load(WasmI32.fromGrain(number), _VALUE_OFFSET)
+  let result = newInt32(x)
+  WasmI32.toGrain(result): Int32
+}
 
 /**
  * Increments the value by one.
@@ -51,9 +66,9 @@ export toNumber
  * @since v0.2.0
  */
 @unsafe
-export let incr = (value: Int32) => {
+provide let incr = (value: Int32) => {
   let value = WasmI32.fromGrain(value)
-  let ptr = newInt32(WasmI32.add(WasmI32.load(value, 8n), 1n))
+  let ptr = newInt32(WasmI32.load(value, _VALUE_OFFSET) + 1n)
   WasmI32.toGrain(ptr): Int32
 }
 
@@ -66,9 +81,9 @@ export let incr = (value: Int32) => {
  * @since v0.2.0
  */
 @unsafe
-export let decr = (value: Int32) => {
+provide let decr = (value: Int32) => {
   let value = WasmI32.fromGrain(value)
-  let ptr = newInt32(WasmI32.sub(WasmI32.load(value, 8n), 1n))
+  let ptr = newInt32(WasmI32.load(value, _VALUE_OFFSET) - 1n)
   WasmI32.toGrain(ptr): Int32
 }
 
@@ -79,13 +94,14 @@ export let decr = (value: Int32) => {
  * @param y: The second operand
  * @returns The sum of the two operands
  *
- * @since v0.2.0
+ * @since v0.6.0
+ * @history v0.2.0: Originally named `add`
  */
 @unsafe
-export let add = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  let ptr = newInt32(WasmI32.add(xv, yv))
+provide let (+) = (x: Int32, y: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newInt32(xv + yv)
   WasmI32.toGrain(ptr): Int32
 }
 
@@ -96,13 +112,14 @@ export let add = (x: Int32, y: Int32) => {
  * @param y: The second operand
  * @returns The difference of the two operands
  *
- * @since v0.2.0
+ * @since v0.6.0
+ * @history v0.2.0: Originally named `sub`
  */
 @unsafe
-export let sub = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  let ptr = newInt32(WasmI32.sub(xv, yv))
+provide let (-) = (x: Int32, y: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newInt32(xv - yv)
   WasmI32.toGrain(ptr): Int32
 }
 
@@ -113,13 +130,14 @@ export let sub = (x: Int32, y: Int32) => {
  * @param y: The second operand
  * @returns The product of the two operands
  *
- * @since v0.2.0
+ * @since v0.6.0
+ * @history v0.2.0: Originally named `mul`
  */
 @unsafe
-export let mul = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  let ptr = newInt32(WasmI32.mul(xv, yv))
+provide let (*) = (x: Int32, y: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newInt32(xv * yv)
   WasmI32.toGrain(ptr): Int32
 }
 
@@ -130,30 +148,14 @@ export let mul = (x: Int32, y: Int32) => {
  * @param y: The second operand
  * @returns The quotient of its operands
  *
- * @since v0.2.0
- */
-@unsafe
-export let div = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  let ptr = newInt32(WasmI32.divS(xv, yv))
-  WasmI32.toGrain(ptr): Int32
-}
-
-/**
- * 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
+ * @since v0.6.0
+ * @history v0.2.0: Originally named `div`
  */
 @unsafe
-export let divU = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  let ptr = newInt32(WasmI32.divU(xv, yv))
+provide let (/) = (x: Int32, y: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newInt32(xv / yv)
   WasmI32.toGrain(ptr): Int32
 }
 
@@ -167,34 +169,18 @@ export let divU = (x: Int32, y: Int32) => {
  * @since v0.2.0
  */
 @unsafe
-export let rem = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
+provide let rem = (x: Int32, y: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
   let ptr = newInt32(WasmI32.remS(xv, yv))
   WasmI32.toGrain(ptr): Int32
 }
 
-/**
- * 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: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  let ptr = newInt32(WasmI32.remU(xv, yv))
-  WasmI32.toGrain(ptr): Int32
-}
-
 @unsafe
 let abs = n => {
-  let mask = WasmI32.shrS(n, 31n)
-  WasmI32.sub(WasmI32.xor(n, mask), mask)
+  use WasmI32.{ (-) }
+  let mask = n >> 31n
+  (n ^ mask) - mask
 }
 
 /**
@@ -207,37 +193,31 @@ let abs = n => {
  *
  * @throws ModuloByZero: When `y` is zero
  *
- * @since v0.2.0
+ * @since v0.6.0
+ * @history v0.2.0: Originally named `mod`
  */
 @unsafe
-export let mod = (x: Int32, y: Int32) => {
-  let xval = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yval = WasmI32.load(WasmI32.fromGrain(y), 8n)
+provide let (%) = (x: Int32, y: Int32) => {
+  use WasmI32.{ (-) }
+  let xval = WasmI32.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yval = WasmI32.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
 
   if (WasmI32.eqz(yval)) {
     throw Exception.ModuloByZero
   }
 
-  let ptr = if (WasmI32.ltS(WasmI32.xor(xval, yval), 0n)) {
+  let ptr = if ((xval ^ yval) < 0n) {
     let xabs = abs(xval)
     let yabs = abs(yval)
     let mval = WasmI32.remS(xabs, yabs)
-    let mres = WasmI32.sub(yabs, mval)
-    newInt32(
-      if (WasmI32.ne(mval, 0n)) (
-        if (WasmI32.ltS(yval, 0n)) WasmI32.sub(0n, mres) else mres
-      ) else 0n
-    )
+    let mres = yabs - mval
+    newInt32(if (mval != 0n) (if (yval < 0n) 0n - mres else mres) else 0n)
   } else {
     newInt32(WasmI32.remS(xval, yval))
   }
   WasmI32.toGrain(ptr): Int32
 }
 
-/**
- * @section Bitwise operations: Functions for operating on bits of Int32 values.
- */
-
 /**
  * Rotates the bits of the value left by the given number of bits.
  *
@@ -248,9 +228,9 @@ export let mod = (x: Int32, y: Int32) => {
  * @since v0.4.0
  */
 @unsafe
-export let rotl = (value: Int32, amount: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(value), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(amount), 8n)
+provide let rotl = (value: Int32, amount: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(amount), _VALUE_OFFSET)
   let ptr = newInt32(WasmI32.rotl(xv, yv))
   WasmI32.toGrain(ptr): Int32
 }
@@ -265,9 +245,9 @@ export let rotl = (value: Int32, amount: Int32) => {
  * @since v0.4.0
  */
 @unsafe
-export let rotr = (value: Int32, amount: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(value), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(amount), 8n)
+provide let rotr = (value: Int32, amount: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(amount), _VALUE_OFFSET)
   let ptr = newInt32(WasmI32.rotr(xv, yv))
   WasmI32.toGrain(ptr): Int32
 }
@@ -279,13 +259,14 @@ export let rotr = (value: Int32, amount: Int32) => {
  * @param amount: The number of bits to shift by
  * @returns The shifted value
  *
- * @since v0.2.0
+ * @since v0.6.0
+ * @history v0.2.0: Originally named `shl`
  */
 @unsafe
-export let shl = (value: Int32, amount: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(value), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(amount), 8n)
-  let ptr = newInt32(WasmI32.shl(xv, yv))
+provide let (<<) = (value: Int32, amount: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(amount), _VALUE_OFFSET)
+  let ptr = newInt32(xv << yv)
   WasmI32.toGrain(ptr): Int32
 }
 
@@ -296,37 +277,17 @@ export let shl = (value: Int32, amount: Int32) => {
  * @param amount: The amount to shift by
  * @returns The shifted value
  *
- * @since v0.2.0
- */
-@unsafe
-export let shr = (value: Int32, amount: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(value), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(amount), 8n)
-  let ptr = newInt32(WasmI32.shrS(xv, yv))
-  WasmI32.toGrain(ptr): Int32
-}
-
-/**
- * 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
+ * @since v0.6.0
+ * @history v0.2.0: Originally named `shr`
  */
 @unsafe
-export let shrU = (value: Int32, amount: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(value), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(amount), 8n)
-  let ptr = newInt32(WasmI32.shrU(xv, yv))
+provide let (>>) = (value: Int32, amount: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(amount), _VALUE_OFFSET)
+  let ptr = newInt32(xv >> yv)
   WasmI32.toGrain(ptr): Int32
 }
 
-/**
- * @section Comparisons: Functions for comparing Int32 values.
- */
-
 /**
  * Checks if the first value is equal to the second value.
  *
@@ -334,13 +295,14 @@ export let shrU = (value: Int32, amount: Int32) => {
  * @param y: The second value
  * @returns `true` if the first value is equal to the second value or `false` otherwise
  *
- * @since v0.4.0
+ * @since v0.6.0
+ * @history v0.4.0: Originally named `eq`
  */
 @unsafe
-export let eq = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  WasmI32.eq(xv, yv)
+provide let (==) = (x: Int32, y: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  xv == yv
 }
 
 /**
@@ -350,13 +312,14 @@ export let eq = (x: Int32, y: Int32) => {
  * @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
+ * @since v0.6.0
+ * @history v0.4.0: Originally named `ne`
  */
 @unsafe
-export let ne = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  WasmI32.ne(xv, yv)
+provide let (!=) = (x: Int32, y: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  xv != yv
 }
 
 /**
@@ -368,8 +331,8 @@ export let ne = (x: Int32, y: Int32) => {
  * @since v0.4.0
  */
 @unsafe
-export let eqz = (value: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(value), 8n)
+provide let eqz = (value: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
   WasmI32.eqz(xv)
 }
 
@@ -380,29 +343,14 @@ export let eqz = (value: Int32) => {
  * @param y: The second value
  * @returns `true` if the first value is less than the second value or `false` otherwise
  *
- * @since v0.2.0
+ * @since v0.6.0
+ * @history v0.2.0: Originally named `lt`
  */
 @unsafe
-export let lt = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  WasmI32.ltS(xv, yv)
-}
-
-/**
- * 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 ltU = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  WasmI32.ltU(xv, yv)
+provide let (<) = (x: Int32, y: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  xv < yv
 }
 
 /**
@@ -412,29 +360,14 @@ export let ltU = (x: Int32, y: Int32) => {
  * @param y: The second value
  * @returns `true` if the first value is greater than the second value or `false` otherwise
  *
- * @since v0.2.0
+ * @since v0.6.0
+ * @history v0.2.0: Originally named `gt`
  */
 @unsafe
-export let gt = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  WasmI32.gtS(xv, yv)
-}
-
-/**
- * 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 gtU = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  WasmI32.gtU(xv, yv)
+provide let (>) = (x: Int32, y: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  xv > yv
 }
 
 /**
@@ -444,29 +377,14 @@ export let gtU = (x: Int32, y: Int32) => {
  * @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
+ * @since v0.6.0
+ * @history v0.2.0: Originally named `lte`
  */
 @unsafe
-export let lte = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  WasmI32.leS(xv, yv)
-}
-
-/**
- * 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 lteU = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  WasmI32.leU(xv, yv)
+provide let (<=) = (x: Int32, y: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  xv <= yv
 }
 
 /**
@@ -476,35 +394,16 @@ export let lteU = (x: Int32, y: Int32) => {
  * @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: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  WasmI32.geS(xv, yv)
-}
-
-/**
- * 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
+ * @since v0.6.0
+ * @history v0.2.0: Originally named `gte`
  */
 @unsafe
-export let gteU = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  WasmI32.geU(xv, yv)
+provide let (>=) = (x: Int32, y: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  xv >= yv
 }
 
-/**
- * @section Bitwise logic: Boolean operations on the bits of Int32 values.
- */
-
 /**
  * Computes the bitwise NOT of the given value.
  *
@@ -514,9 +413,9 @@ export let gteU = (x: Int32, y: Int32) => {
  * @since v0.2.0
  */
 @unsafe
-export let lnot = (value: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(value), 8n)
-  let ptr = newInt32(WasmI32.xor(xv, 0xffffffffn))
+provide let lnot = (value: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
+  let ptr = newInt32(xv ^ 0xffffffffn)
   WasmI32.toGrain(ptr): Int32
 }
 
@@ -527,13 +426,14 @@ export let lnot = (value: Int32) => {
  * @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
+ * @since v0.6.0
+ * @history v0.2.0: Originally named `land`
  */
 @unsafe
-export let land = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  let ptr = newInt32(WasmI32.and(xv, yv))
+provide let (&) = (x: Int32, y: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newInt32(xv & yv)
   WasmI32.toGrain(ptr): Int32
 }
 
@@ -544,13 +444,14 @@ export let land = (x: Int32, y: Int32) => {
  * @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
+ * @since v0.6.0
+ * @history v0.2.0: Originally named `lor`
  */
 @unsafe
-export let lor = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  let ptr = newInt32(WasmI32.or(xv, yv))
+provide let (|) = (x: Int32, y: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newInt32(xv | yv)
   WasmI32.toGrain(ptr): Int32
 }
 
@@ -561,13 +462,14 @@ export let lor = (x: Int32, y: Int32) => {
  * @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
+ * @since v0.6.0
+ * @history v0.2.0: Originally named `lxor`
  */
 @unsafe
-export let lxor = (x: Int32, y: Int32) => {
-  let xv = WasmI32.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmI32.load(WasmI32.fromGrain(y), 8n)
-  let ptr = newInt32(WasmI32.xor(xv, yv))
+provide let (^) = (x: Int32, y: Int32) => {
+  let xv = WasmI32.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmI32.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newInt32(xv ^ yv)
   WasmI32.toGrain(ptr): Int32
 }
 
@@ -580,8 +482,8 @@ export let lxor = (x: Int32, y: Int32) => {
  * @since v0.4.0
  */
 @unsafe
-export let clz = (value: Int32) => {
-  let nv = WasmI32.load(WasmI32.fromGrain(value), 8n)
+provide let clz = (value: Int32) => {
+  let nv = WasmI32.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
   let ptr = newInt32(WasmI32.clz(nv))
   WasmI32.toGrain(ptr): Int32
 }
@@ -595,8 +497,8 @@ export let clz = (value: Int32) => {
  * @since v0.4.0
  */
 @unsafe
-export let ctz = (value: Int32) => {
-  let nv = WasmI32.load(WasmI32.fromGrain(value), 8n)
+provide let ctz = (value: Int32) => {
+  let nv = WasmI32.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
   let ptr = newInt32(WasmI32.ctz(nv))
   WasmI32.toGrain(ptr): Int32
 }
@@ -610,8 +512,37 @@ export let ctz = (value: Int32) => {
  * @since v0.4.0
  */
 @unsafe
-export let popcnt = (value: Int32) => {
-  let nv = WasmI32.load(WasmI32.fromGrain(value), 8n)
+provide let popcnt = (value: Int32) => {
+  let nv = WasmI32.load(WasmI32.fromGrain(value), _VALUE_OFFSET)
   let ptr = newInt32(WasmI32.popcnt(nv))
   WasmI32.toGrain(ptr): Int32
 }
+
+// Exponentiation by squaring https://en.wikipedia.org/wiki/Exponentiation_by_squaring special path for int^int
+let rec expBySquaring = (y, x, n) => {
+  if (n == 0l) {
+    1l
+  } else if (n == 1l) {
+    x * y
+  } else if (n % 2l == 0l) {
+    expBySquaring(y, x * x, n / 2l)
+  } else {
+    expBySquaring(x * y, x * x, (n - 1l) / 2l)
+  }
+}
+
+/**
+ * Computes the exponentiation of the given base and power.
+ *
+ * @param base: The base number
+ * @param power: The exponent number
+ * @returns The base raised to the given power
+ *
+ * @since v0.6.0
+ */
+provide let (**) = (base, power) => {
+  if (power < 0l)
+    return expBySquaring(1l, 1l / base, power * -1l)
+  else
+    return expBySquaring(1l, base, power)
+}