@grain/stdlib 0.5.12 → 0.6.0

package/int16.gr

@@ -0,0 +1,430 @@
+/**
+ * Utilities for working with the Int16 type.
+ * @example from "int16" include Int16
+ *
+ * @since v0.6.0
+ */
+module Int16
+
+from "runtime/unsafe/wasmi32" include WasmI32
+use WasmI32.{
+  (+),
+  (-),
+  (*),
+  (/),
+  (&),
+  (|),
+  (^),
+  (<<),
+  (>>),
+  (==),
+  (!=),
+  (<),
+  (<=),
+  (>),
+  (>=),
+}
+from "runtime/exception" include Exception
+from "runtime/numbers" include Numbers
+use Numbers.{
+  coerceNumberToInt16 as fromNumber,
+  coerceInt16ToNumber as toNumber,
+}
+from "runtime/dataStructures" include DataStructures
+use DataStructures.{ tagInt16, untagInt16 }
+
+@unsafe
+let _DATA_OFFSET = 8n
+@unsafe
+let _TAG_BYTE = 0b10010n
+@unsafe
+let _DATA_MASK = 0xffffff00n
+
+provide { fromNumber, toNumber }
+
+@unsafe
+let signExtend = x => (x << _DATA_OFFSET) >> _DATA_OFFSET
+
+/**
+ * Converts a Uint16 to an Int16.
+ *
+ * @param number: The value to convert
+ * @returns The Uint16 represented as an Int16
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let fromUint16 = (number: Uint16) => {
+  let x = WasmI32.fromGrain(number)
+  // Trick: convert from Uint16 tag 100010 to Int16 tag 10010
+  let result = x ^ 0b110000n
+  WasmI32.toGrain(signExtend(result)): Int16
+}
+
+/**
+ * Increments the value by one.
+ *
+ * @param value: The value to increment
+ * @returns The incremented value
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let incr = (value: Int16) => {
+  let value = WasmI32.fromGrain(value)
+  // Trick: since the data is at offset 8, can just add 1 << 8 == 0x100
+  let result = value + 0x100n
+  WasmI32.toGrain(signExtend(result)): Int16
+}
+
+/**
+ * Decrements the value by one.
+ *
+ * @param value: The value to decrement
+ * @returns The decremented value
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let decr = (value: Int16) => {
+  let value = WasmI32.fromGrain(value)
+  // Trick: since the data is at offset 8, can just subtract 1 << 8 == 0x100
+  let result = value - 0x100n
+  WasmI32.toGrain(signExtend(result)): Int16
+}
+
+/**
+ * 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.6.0
+ */
+@unsafe
+provide let (+) = (x: Int16, y: Int16) => {
+  // Trick: add the values as-is without shifting right 8; this will cause
+  // the data to be added correctly but the trailing tag bits will be corrupted:
+  // 10010 + 10010 = 100100; xor with 110110 to correct to 10010
+  let x = WasmI32.fromGrain(x)
+  let y = WasmI32.fromGrain(y)
+  let val = x + y
+  let tagged = val ^ 0b110110n
+  WasmI32.toGrain(signExtend(tagged)): Int16
+}
+
+/**
+ * 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.6.0
+ */
+@unsafe
+provide let (-) = (x: Int16, y: Int16) => {
+  let x = WasmI32.fromGrain(x)
+  let y = WasmI32.fromGrain(y)
+  let val = x - y
+  let tagged = val | _TAG_BYTE
+  WasmI32.toGrain(signExtend(tagged)): Int16
+}
+
+/**
+ * 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.6.0
+ */
+@unsafe
+provide let (*) = (x: Int16, y: Int16) => {
+  let x = untagInt16(x)
+  let y = untagInt16(y)
+  let val = WasmI32.extendS16(x * y)
+  tagInt16(val)
+}
+
+/**
+ * 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.6.0
+ */
+@unsafe
+provide let (/) = (x: Int16, y: Int16) => {
+  let x = untagInt16(x)
+  let y = untagInt16(y)
+  // No need to re-sign-extend
+  let val = x / y
+  tagInt16(val)
+}
+
+/**
+ * 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.6.0
+ */
+@unsafe
+provide let rem = (x: Int16, y: Int16) => {
+  let x = untagInt16(x)
+  let y = untagInt16(y)
+  // No need to re-sign-extend
+  let val = WasmI32.remS(x, y)
+  tagInt16(val)
+}
+
+@unsafe
+let abs = n => {
+  use WasmI32.{ (-) }
+  let mask = n >> 31n
+  (n ^ mask) - mask
+}
+
+/**
+ * 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
+ *
+ * @throws ModuloByZero: When `y` is zero
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let (%) = (x: Int16, y: Int16) => {
+  use WasmI32.{ (-) }
+  let xval = untagInt16(x)
+  let yval = untagInt16(y)
+
+  if (WasmI32.eqz(yval)) {
+    throw Exception.ModuloByZero
+  }
+
+  let val = if ((xval ^ yval) < 0n) {
+    let xabs = abs(xval)
+    let yabs = abs(yval)
+    let mval = WasmI32.remS(xabs, yabs)
+    let mres = yabs - mval
+    if (mval != 0n) (if (yval < 0n) 0n - mres else mres) else 0n
+  } else {
+    WasmI32.remS(xval, yval)
+  }
+  tagInt16(val)
+}
+
+/**
+ * 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.6.0
+ */
+@unsafe
+provide let (<<) = (value: Int16, amount: Int16) => {
+  // Trick: do not shift `value` right, just correct tag afterwards
+  let x = WasmI32.fromGrain(value) & _DATA_MASK
+  let y = untagInt16(amount)
+  let val = x << y
+  let tagged = val | _TAG_BYTE
+  WasmI32.toGrain(signExtend(tagged)): Int16
+}
+
+/**
+ * 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.6.0
+ */
+@unsafe
+provide let (>>) = (value: Int16, amount: Int16) => {
+  // Trick: do not shift `value` right, just correct tag afterwards
+  let x = WasmI32.fromGrain(value)
+  let y = untagInt16(amount)
+  let val = x >> y
+  let tagged = val & _DATA_MASK | _TAG_BYTE
+  WasmI32.toGrain(tagged): Int16
+}
+
+/**
+ * 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.6.0
+ */
+@unsafe
+provide let (==) = (x: Int16, y: Int16) => {
+  let x = WasmI32.fromGrain(x)
+  let y = WasmI32.fromGrain(y)
+  x == y
+}
+
+/**
+ * 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.6.0
+ */
+@unsafe
+provide let (!=) = (x: Int16, y: Int16) => {
+  let x = WasmI32.fromGrain(x)
+  let y = WasmI32.fromGrain(y)
+  x != y
+}
+
+/**
+ * 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.6.0
+ */
+@unsafe
+provide let (<) = (x: Int16, y: Int16) => {
+  let x = WasmI32.fromGrain(x)
+  let y = WasmI32.fromGrain(y)
+  x < y
+}
+
+/**
+ * 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.6.0
+ */
+@unsafe
+provide let (>) = (x: Int16, y: Int16) => {
+  let x = WasmI32.fromGrain(x)
+  let y = WasmI32.fromGrain(y)
+  x > y
+}
+
+/**
+ * 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.6.0
+ */
+@unsafe
+provide let (<=) = (x: Int16, y: Int16) => {
+  let x = WasmI32.fromGrain(x)
+  let y = WasmI32.fromGrain(y)
+  x <= y
+}
+
+/**
+ * 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.6.0
+ */
+@unsafe
+provide let (>=) = (x: Int16, y: Int16) => {
+  let x = WasmI32.fromGrain(x)
+  let y = WasmI32.fromGrain(y)
+  x >= y
+}
+
+/**
+ * Computes the bitwise NOT of the given value.
+ *
+ * @param value: The given value
+ * @returns Containing the inverted bits of the given value
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let lnot = (value: Int16) => {
+  let x = WasmI32.fromGrain(value)
+  WasmI32.toGrain(x ^ _DATA_MASK): Int16
+}
+
+/**
+ * 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.6.0
+ */
+@unsafe
+provide let (&) = (x: Int16, y: Int16) => {
+  // Tags getting `and`ed together is not a problem
+  let x = WasmI32.fromGrain(x)
+  let y = WasmI32.fromGrain(y)
+  let val = x & y
+  WasmI32.toGrain(val): Int16
+}
+
+/**
+ * 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.6.0
+ */
+@unsafe
+provide let (|) = (x: Int16, y: Int16) => {
+  // Tags getting `or`ed together is not a problem
+  let x = WasmI32.fromGrain(x)
+  let y = WasmI32.fromGrain(y)
+  let val = x | y
+  WasmI32.toGrain(val): Int16
+}
+
+/**
+ * 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.6.0
+ */
+@unsafe
+provide let (^) = (x: Int16, y: Int16) => {
+  use WasmI32.{ (|) }
+  // Tags getting `xor`ed together will cancel each other out; add back tag with or
+  let x = WasmI32.fromGrain(x)
+  let y = WasmI32.fromGrain(y)
+  let val = x ^ y
+  WasmI32.toGrain(val | _TAG_BYTE): Int16
+}