@grain/stdlib 0.5.2 → 0.5.4

package/runtime/numbers.gr

@@ -20,6 +20,7 @@ primitive (||): (Bool, Bool) -> Bool = "@or"
 primitive throw: Exception -> a = "@throw"
 
 exception UnknownNumberTag
+exception InvariantViolation
 
 import {
   newRational,
@@ -78,7 +79,29 @@ export let isFloat = x => {
   if (isBoxedNumber(x)) {
     let tag = WasmI32.load(x, 4n)
     WasmI32.eq(tag, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) ||
-    WasmI32.eq(tag, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)
+      WasmI32.eq(tag, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)
+  } else {
+    false
+  }
+}
+
+@unsafe
+export let isInteger = x => {
+  if (isBoxedNumber(x)) {
+    let tag = WasmI32.load(x, 4n)
+    WasmI32.eq(tag, Tags._GRAIN_INT32_BOXED_NUM_TAG) ||
+      WasmI32.eq(tag, Tags._GRAIN_INT64_BOXED_NUM_TAG) ||
+      WasmI32.eq(tag, Tags._GRAIN_BIGINT_BOXED_NUM_TAG)
+  } else {
+    true
+  }
+}
+
+@unsafe
+export let isRational = x => {
+  if (isBoxedNumber(x)) {
+    let tag = WasmI32.load(x, 4n)
+    WasmI32.eq(tag, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG)
   } else {
     false
   }
@@ -495,13 +518,13 @@ let isIntegerF64 = value => {
 @unsafe
 let isSafeIntegerF32 = value => {
   WasmF32.le(WasmF32.abs(value), _F32_MAX_SAFE_INTEGER) &&
-  WasmF32.eq(WasmF32.trunc(value), value)
+    WasmF32.eq(WasmF32.trunc(value), value)
 }
 
 @unsafe
 let isSafeIntegerF64 = value => {
   WasmF64.le(WasmF64.abs(value), _F64_MAX_SAFE_INTEGER) &&
-  WasmF64.eq(WasmF64.trunc(value), value)
+    WasmF64.eq(WasmF64.trunc(value), value)
 }
 
 /** Number-aware equality checking
@@ -541,12 +564,12 @@ let numberEqualSimpleHelp = (x, y) => {
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat32Number(y)
         isSafeIntegerF32(yBoxedVal) &&
-        WasmF32.eq(WasmF32.convertI32S(xval), yBoxedVal)
+          WasmF32.eq(WasmF32.convertI32S(xval), yBoxedVal)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat64Number(y)
         isSafeIntegerF64(yBoxedVal) &&
-        WasmF64.eq(WasmF64.convertI32S(xval), yBoxedVal)
+          WasmF64.eq(WasmF64.convertI32S(xval), yBoxedVal)
       },
       _ => {
         throw UnknownNumberTag
@@ -583,12 +606,12 @@ let numberEqualInt64Help = (xBoxedVal, y) => {
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat32Number(y)
         isSafeIntegerF32(yBoxedVal) &&
-        WasmI64.eq(xBoxedVal, WasmI64.truncF32S(yBoxedVal))
+          WasmI64.eq(xBoxedVal, WasmI64.truncF32S(yBoxedVal))
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat64Number(y)
         isSafeIntegerF64(yBoxedVal) &&
-        WasmI64.eq(xBoxedVal, WasmI64.truncF64S(yBoxedVal))
+          WasmI64.eq(xBoxedVal, WasmI64.truncF64S(yBoxedVal))
       },
       _ => {
         throw UnknownNumberTag
@@ -635,7 +658,7 @@ let numberEqualRationalHelp = (xptr, y) => {
           BI.toFloat32(xNumerator),
           BI.toFloat32(xDenominator)
         )
-        // TODO: (#303) maybe we should have some sort of tolerance?
+        // TODO(#303): maybe we should have some sort of tolerance?
         WasmF32.eq(xAsFloat, yBoxedVal)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
@@ -644,7 +667,7 @@ let numberEqualRationalHelp = (xptr, y) => {
           BI.toFloat64(xNumerator),
           BI.toFloat64(xDenominator)
         )
-        // TODO: (#303) maybe we should have some sort of tolerance?
+        // TODO(#303): maybe we should have some sort of tolerance?
         WasmF64.eq(xAsFloat, yBoxedVal)
       },
       _ => {
@@ -686,12 +709,12 @@ let numberEqualFloat64Help = (x, y) => {
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat32Number(y)
-        // TODO: (#303) maybe we should have some sort of tolerance?
+        // TODO(#303): maybe we should have some sort of tolerance?
         WasmF64.eq(x, WasmF64.promoteF32(yBoxedVal))
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat64Number(y)
-        // TODO: (#303) maybe we should have some sort of tolerance?
+        // TODO(#303): maybe we should have some sort of tolerance?
         WasmF64.eq(x, yBoxedVal)
       },
       _ => {
@@ -820,14 +843,16 @@ let numberAddSubSimpleHelp = (x, y, isSub) => {
       t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
         let xval = WasmI64.extendI32S(xval)
         let yBoxedVal = WasmI64.extendI32S(boxedInt32Number(y))
-        let result = if (isSub) WasmI64.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmI64.sub(xval, yBoxedVal)
           else WasmI64.add(xval, yBoxedVal)
         reducedInteger(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedInt64Number(y)
         let xval64 = WasmI64.extendI32S(xval)
-        let result = if (isSub) WasmI64.sub(xval64, yBoxedVal)
+        let result =
+          if (isSub) WasmI64.sub(xval64, yBoxedVal)
           else WasmI64.add(xval64, yBoxedVal)
         if (
           WasmI64.geS(yBoxedVal, 0N) && WasmI64.ltS(result, xval64) ||
@@ -861,7 +886,8 @@ let numberAddSubSimpleHelp = (x, y, isSub) => {
         let yDenominator = boxedRationalDenominator(y)
         let expandedXNumerator = BI.mul(xBig, yDenominator)
         Memory.decRef(xBig)
-        let result = if (isSub) BI.sub(expandedXNumerator, yNumerator)
+        let result =
+          if (isSub) BI.sub(expandedXNumerator, yNumerator)
           else BI.add(expandedXNumerator, yNumerator)
         let ret = reducedFractionBigInt(result, yDenominator)
         Memory.decRef(expandedXNumerator)
@@ -871,15 +897,16 @@ let numberAddSubSimpleHelp = (x, y, isSub) => {
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat32Number(y)
         let xval = WasmF32.convertI32S(xval)
-        let result = if (isSub) WasmF32.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF32.sub(xval, yBoxedVal)
           else WasmF32.add(xval, yBoxedVal)
-        // TODO: (#304) is this safe?
         newFloat32(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat64Number(y)
         let xval = WasmF64.convertI32S(xval)
-        let result = if (isSub) WasmF64.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF64.sub(xval, yBoxedVal)
           else WasmF64.add(xval, yBoxedVal)
         newFloat64(result)
       },
@@ -918,14 +945,16 @@ let numberAddSubInt64Help = (xval, y, isSub) => {
     match (yBoxedNumberTag) {
       t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
         let yBoxedVal = WasmI64.extendI32S(boxedInt32Number(y))
-        let result = if (isSub) WasmI64.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmI64.sub(xval, yBoxedVal)
           else WasmI64.add(xval, yBoxedVal)
         reducedInteger(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedInt64Number(y)
         let xval64 = xval
-        let result = if (isSub) WasmI64.sub(xval64, yBoxedVal)
+        let result =
+          if (isSub) WasmI64.sub(xval64, yBoxedVal)
           else WasmI64.add(xval64, yBoxedVal)
         if (
           WasmI64.geS(yBoxedVal, 0N) && WasmI64.ltS(result, xval64) ||
@@ -959,7 +988,8 @@ let numberAddSubInt64Help = (xval, y, isSub) => {
         let yDenominator = boxedRationalDenominator(y)
         let expandedXNumerator = BI.mul(xBig, yDenominator)
         Memory.decRef(xBig)
-        let result = if (isSub) BI.sub(expandedXNumerator, yNumerator)
+        let result =
+          if (isSub) BI.sub(expandedXNumerator, yNumerator)
           else BI.add(expandedXNumerator, yNumerator)
         let ret = reducedFractionBigInt(result, yDenominator)
         Memory.decRef(expandedXNumerator)
@@ -969,15 +999,16 @@ let numberAddSubInt64Help = (xval, y, isSub) => {
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let xval = WasmF32.convertI64S(xval)
         let yBoxedVal = boxedFloat32Number(y)
-        let result = if (isSub) WasmF32.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF32.sub(xval, yBoxedVal)
           else WasmF32.add(xval, yBoxedVal)
-        // TODO(#304): this isn't safe enough
         newFloat32(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let xval = WasmF64.convertI64S(xval)
         let yBoxedVal = boxedFloat64Number(y)
-        let result = if (isSub) WasmF64.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF64.sub(xval, yBoxedVal)
           else WasmF64.add(xval, yBoxedVal)
         newFloat64(result)
       },
@@ -1071,7 +1102,8 @@ let numberAddSubBigIntHelp = (x, y, isSub) => {
         let yNumerator = boxedRationalNumerator(y)
         let yDenominator = boxedRationalDenominator(y)
         let expandedXNumerator = BI.mul(x, yDenominator)
-        let result = if (isSub) BI.sub(expandedXNumerator, yNumerator)
+        let result =
+          if (isSub) BI.sub(expandedXNumerator, yNumerator)
           else BI.add(expandedXNumerator, yNumerator)
         Memory.decRef(expandedXNumerator)
         let ret = reducedFractionBigInt(result, yDenominator)
@@ -1081,15 +1113,16 @@ let numberAddSubBigIntHelp = (x, y, isSub) => {
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let xval = BI.toFloat32(x)
         let yBoxedVal = boxedFloat32Number(y)
-        let result = if (isSub) WasmF32.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF32.sub(xval, yBoxedVal)
           else WasmF32.add(xval, yBoxedVal)
-        // TODO: (#304) this isn't safe enough
         newFloat32(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let xval = BI.toFloat64(x)
         let yBoxedVal = boxedFloat64Number(y)
-        let result = if (isSub) WasmF64.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF64.sub(xval, yBoxedVal)
           else WasmF64.add(xval, yBoxedVal)
         newFloat64(result)
       },
@@ -1108,7 +1141,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
     let yval = untagSimple(y)
     let yBig = BI.makeWrappedInt32(yval)
     let expandedYNumerator = BI.mul(xDenominator, yBig)
-    let result = if (isSub) BI.sub(xNumerator, expandedYNumerator)
+    let result =
+      if (isSub) BI.sub(xNumerator, expandedYNumerator)
       else BI.add(xNumerator, expandedYNumerator)
     Memory.decRef(expandedYNumerator)
     Memory.decRef(yBig)
@@ -1125,7 +1159,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
         let yNumerator = boxedRationalNumerator(y)
         let yDenominator = boxedRationalDenominator(y)
         if (BI.eq(xDenominator, yDenominator)) {
-          let newNumerator = if (isSub) BI.sub(xNumerator, yNumerator)
+          let newNumerator =
+            if (isSub) BI.sub(xNumerator, yNumerator)
             else BI.add(xNumerator, yNumerator)
           let ret = reducedFractionBigInt(newNumerator, xDenominator)
           Memory.decRef(newNumerator)
@@ -1133,7 +1168,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
         } else {
           let numerator1 = BI.mul(xNumerator, yDenominator)
           let numerator2 = BI.mul(yNumerator, xDenominator)
-          let numerator = if (isSub) BI.sub(numerator1, numerator2)
+          let numerator =
+            if (isSub) BI.sub(numerator1, numerator2)
             else BI.add(numerator1, numerator2)
           let denominator = BI.mul(xDenominator, yDenominator)
           let ret = reducedFractionBigInt(numerator, denominator)
@@ -1147,7 +1183,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
         let yBig = BI.makeWrappedInt32(boxedInt32Number(y))
         let expandedYNumerator = BI.mul(yBig, xDenominator)
         Memory.decRef(yBig)
-        let result = if (isSub) BI.sub(xNumerator, expandedYNumerator)
+        let result =
+          if (isSub) BI.sub(xNumerator, expandedYNumerator)
           else BI.add(xNumerator, expandedYNumerator)
         let ret = reducedFractionBigInt(result, xDenominator)
         Memory.decRef(expandedYNumerator)
@@ -1158,7 +1195,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
         let yBig = BI.makeWrappedInt64(boxedInt64Number(y))
         let expandedYNumerator = BI.mul(yBig, xDenominator)
         Memory.decRef(yBig)
-        let result = if (isSub) BI.sub(xNumerator, expandedYNumerator)
+        let result =
+          if (isSub) BI.sub(xNumerator, expandedYNumerator)
           else BI.add(xNumerator, expandedYNumerator)
         let ret = reducedFractionBigInt(result, xDenominator)
         Memory.decRef(expandedYNumerator)
@@ -1167,7 +1205,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
       },
       t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
         let expandedYNumerator = BI.mul(xDenominator, y)
-        let result = if (isSub) BI.sub(xNumerator, expandedYNumerator)
+        let result =
+          if (isSub) BI.sub(xNumerator, expandedYNumerator)
           else BI.add(xNumerator, expandedYNumerator)
         Memory.decRef(expandedYNumerator)
         let ret = reducedFractionBigInt(result, xDenominator)
@@ -1179,7 +1218,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
           BI.toFloat32(xNumerator),
           BI.toFloat32(xDenominator)
         )
-        let result = if (isSub) WasmF32.sub(xval, boxedFloat32Number(y))
+        let result =
+          if (isSub) WasmF32.sub(xval, boxedFloat32Number(y))
           else WasmF32.add(xval, boxedFloat32Number(y))
         newFloat32(result)
       },
@@ -1188,8 +1228,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
         let xdenfloat = BI.toFloat64(xDenominator)
         let xval = WasmF64.div(xnumfloat, xdenfloat)
         let yval = boxedFloat64Number(y)
-        let result = if (isSub) WasmF64.sub(xval, yval)
-          else WasmF64.add(xval, yval)
+        let result =
+          if (isSub) WasmF64.sub(xval, yval) else WasmF64.add(xval, yval)
         let ret = newFloat64(result)
         ret
       },
@@ -1326,7 +1366,6 @@ let numberTimesDivideInt64Help = (xval, y, isDivide) => {
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let xval = WasmF32.convertI64S(xval)
         let yBoxedVal = boxedFloat32Number(y)
-        // TODO: (#304) is this safe?
         if (isDivide) {
           newFloat32(WasmF32.div(xval, yBoxedVal))
         } else {
@@ -1385,6 +1424,13 @@ let numberTimesDivideBigIntHelp = (x, y, isDivide) => {
         Memory.decRef(yBig)
         ret
       },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        if (isDivide) {
+          reducedBigInteger(BI.div(x, y))
+        } else {
+          reducedBigInteger(BI.mul(x, y))
+        }
+      },
       t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
         let yNumerator = boxedRationalNumerator(y)
         let yDenominator = boxedRationalDenominator(y)
@@ -1407,7 +1453,6 @@ let numberTimesDivideBigIntHelp = (x, y, isDivide) => {
         // we can only fit rather small bigints (<4 limbs) into an F32
         let xval = BI.toFloat64(x)
         let yBoxedVal = WasmF64.promoteF32(boxedFloat32Number(y))
-        // TODO: (#304) is this safe?
         if (isDivide) {
           newFloat64(WasmF64.div(xval, yBoxedVal))
         } else {
@@ -1530,10 +1575,11 @@ let numberTimesDivideRationalHelp = (x, y, isDivide) => {
         let yDenominator = boxedRationalDenominator(y)
         // (a / b) * (c / d) == (a * c) / (b * d)
         // (a / b) / (c / d) == (a * d) / (b * c)
-        // TODO: (#304) this could maybe be written in a more overflow-proof way
-        let numerator = if (isDivide) BI.mul(xNumerator, yDenominator)
+        let numerator =
+          if (isDivide) BI.mul(xNumerator, yDenominator)
           else BI.mul(xNumerator, yNumerator)
-        let denominator = if (isDivide) BI.mul(xDenominator, yNumerator)
+        let denominator =
+          if (isDivide) BI.mul(xDenominator, yNumerator)
           else BI.mul(xDenominator, yDenominator)
         reducedFractionBigInt(numerator, denominator)
       },
@@ -1669,7 +1715,8 @@ let numberMod = (x, y) => {
     WasmI64.gtS(xval, 0N) && WasmI64.ltS(yval, 0N)
   ) {
     let modval = WasmI64.remS(i64abs(xval), i64abs(yval))
-    let result = if (WasmI64.ne(modval, 0N))
+    let result =
+      if (WasmI64.ne(modval, 0N))
         WasmI64.mul(
           WasmI64.sub(i64abs(yval), modval),
           if (WasmI64.ltS(yval, 0N)) -1N else 1N
@@ -1681,9 +1728,18 @@ let numberMod = (x, y) => {
 }
 
 /*
- * ===== LESS THAN / GREATER THAN / LESS EQUAL / GREATER EQUAL =====
- * Coerce to float64 and then do comparisons
- * TODO: (#305) Could probably be made more efficient
+ * ===== COMPARISONS =====
+ * Int/int and float/float comparisons are always accurate.
+ * Rational/rational comparisons are approximations with the exception of
+ * equality, which is always accurate.
+ *
+ * Values compared to floats or rationals are first converted to floats.
+ *
+ * All comparison operators consider NaN not equal to, less than, or greater
+ * than NaN, with the exception of `compare`, which considers NaN equal to
+ * itself and otherwise smaller than any other float value. This provides a
+ * total order (https://en.wikipedia.org/wiki/Total_order) over all numerical
+ * values, making `compare` suitable for sorting or ordering.
  */
 
 @unsafe
@@ -1721,81 +1777,286 @@ let cmpBigInt = (x: WasmI32, y: WasmI32) => {
   }
 }
 
-// TODO: (#305) is this safe? I think it's safe?
 @unsafe
-export let (<) = (x: Number, y: Number) => {
-  let xw32 = WasmI32.fromGrain(x)
-  let yw32 = WasmI32.fromGrain(y)
-  if (isBigInt(xw32)) {
-    WasmI32.ltS(cmpBigInt(xw32, yw32), 0n)
-  } else if (isBigInt(yw32)) {
-    WasmI32.geS(cmpBigInt(yw32, xw32), 0n)
+let cmpFloat = (x: WasmI32, y: WasmI32, is64: Bool, totalOrdering: Bool) => {
+  let xf = if (is64) {
+    boxedFloat64Number(x)
   } else {
-    let xval = coerceNumberToWasmF64(x)
-    let yval = coerceNumberToWasmF64(y)
-    WasmF64.lt(xval, yval)
+    WasmF64.promoteF32(boxedFloat32Number(x))
+  }
+  if (isSimpleNumber(y)) {
+    let yf = WasmF64.convertI32S(untagSimple(y))
+    // special NaN cases
+    if (totalOrdering && WasmF64.ne(xf, xf)) {
+      if (WasmF64.ne(yf, yf)) {
+        0n
+      } else {
+        -1n
+      }
+    } else if (totalOrdering && WasmF64.ne(yf, yf)) {
+      if (WasmF64.ne(xf, xf)) {
+        0n
+      } else {
+        1n
+      }
+    } else {
+      if (WasmF64.lt(xf, yf)) -1n else if (WasmF64.gt(xf, yf)) 1n else 0n
+    }
+  } else {
+    let yBoxedNumberTag = boxedNumberTag(y)
+    if (yBoxedNumberTag == Tags._GRAIN_BIGINT_BOXED_NUM_TAG) {
+      WasmI32.sub(0n, cmpBigInt(y, x))
+    } else {
+      let yf = match (yBoxedNumberTag) {
+        t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
+          WasmF64.convertI32S(boxedInt32Number(y))
+        },
+        t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
+          WasmF64.convertI64S(boxedInt64Number(y))
+        },
+        t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+          throw InvariantViolation
+        },
+        t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
+          WasmF64.div(
+            BI.toFloat64(boxedRationalNumerator(y)),
+            BI.toFloat64(boxedRationalDenominator(y))
+          )
+        },
+        t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
+          WasmF64.promoteF32(boxedFloat32Number(y))
+        },
+        t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
+          boxedFloat64Number(y)
+        },
+        _ => {
+          throw UnknownNumberTag
+        },
+      }
+      // special NaN cases
+      if (totalOrdering && WasmF64.ne(xf, xf)) {
+        if (WasmF64.ne(yf, yf)) {
+          0n
+        } else {
+          -1n
+        }
+      } else if (totalOrdering && WasmF64.ne(yf, yf)) {
+        if (WasmF64.ne(xf, xf)) {
+          0n
+        } else {
+          1n
+        }
+      } else {
+        if (WasmF64.lt(xf, yf)) -1n else if (WasmF64.gt(xf, yf)) 1n else 0n
+      }
+    }
   }
 }
 
 @unsafe
-export let (>) = (x: Number, y: Number) => {
-  let xw32 = WasmI32.fromGrain(x)
-  let yw32 = WasmI32.fromGrain(y)
-  if (isBigInt(xw32)) {
-    WasmI32.gtS(cmpBigInt(xw32, yw32), 0n)
-  } else if (isBigInt(yw32)) {
-    WasmI32.leS(cmpBigInt(yw32, xw32), 0n)
+let cmpSmallInt = (x: WasmI32, y: WasmI32, is64: Bool, totalOrdering: Bool) => {
+  let xi = if (is64) {
+    boxedInt64Number(x)
   } else {
-    let xval = coerceNumberToWasmF64(x)
-    let yval = coerceNumberToWasmF64(y)
-    WasmF64.gt(xval, yval)
+    WasmI64.extendI32S(boxedInt32Number(x))
+  }
+  if (isSimpleNumber(y)) {
+    let yi = WasmI64.extendI32S(untagSimple(y))
+    if (WasmI64.ltS(xi, yi)) -1n else if (WasmI64.gtS(xi, yi)) 1n else 0n
+  } else {
+    let yBoxedNumberTag = boxedNumberTag(y)
+    match (yBoxedNumberTag) {
+      t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
+        let yi = WasmI64.extendI32S(boxedInt32Number(y))
+        if (WasmI64.ltS(xi, yi)) -1n else if (WasmI64.gtS(xi, yi)) 1n else 0n
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
+        let yi = boxedInt64Number(y)
+        if (WasmI64.ltS(xi, yi)) -1n else if (WasmI64.gtS(xi, yi)) 1n else 0n
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        WasmI32.sub(0n, cmpBigInt(y, x))
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
+        // Rationals and ints are never considered equal
+        if (
+          WasmF64.lt(
+            WasmF64.convertI64S(xi),
+            WasmF64.div(
+              BI.toFloat64(boxedRationalNumerator(y)),
+              BI.toFloat64(boxedRationalDenominator(y))
+            )
+          )
+        ) -1n else 1n
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
+        WasmI32.sub(0n, cmpFloat(y, x, false, totalOrdering))
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
+        WasmI32.sub(0n, cmpFloat(y, x, true, totalOrdering))
+      },
+      _ => {
+        throw UnknownNumberTag
+      },
+    }
   }
 }
 
 @unsafe
-export let (<=) = (x: Number, y: Number) => {
-  let xw32 = WasmI32.fromGrain(x)
-  let yw32 = WasmI32.fromGrain(y)
-  if (isBigInt(xw32)) {
-    WasmI32.leS(cmpBigInt(xw32, yw32), 0n)
-  } else if (isBigInt(yw32)) {
-    WasmI32.geS(cmpBigInt(yw32, xw32), 0n)
+let cmpRational = (x: WasmI32, y: WasmI32, totalOrdering: Bool) => {
+  if (isSimpleNumber(y)) {
+    let xf = WasmF64.div(
+      BI.toFloat64(boxedRationalNumerator(x)),
+      BI.toFloat64(boxedRationalDenominator(x))
+    )
+    // Rationals and ints are never considered equal
+    if (WasmF64.lt(xf, WasmF64.convertI32S(untagSimple(y)))) -1n else 1n
   } else {
-    // Equality is finicky, so delegate
-    let xval = coerceNumberToWasmF64(x)
-    let yval = coerceNumberToWasmF64(y)
-    if (WasmF64.lt(xval, yval)) {
-      true
-    } else {
-      let x = WasmI32.fromGrain(x)
-      let y = WasmI32.fromGrain(y)
-      numberEqual(x, y)
+    let yBoxedNumberTag = boxedNumberTag(y)
+    match (yBoxedNumberTag) {
+      t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
+        WasmI32.sub(0n, cmpSmallInt(y, x, false, totalOrdering))
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
+        WasmI32.sub(0n, cmpSmallInt(y, x, true, totalOrdering))
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        WasmI32.sub(0n, cmpBigInt(y, x))
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
+        // Comparing rationals efficiently is an open problem
+        // Producing a definitive answer is quite expensive, so if the two
+        // values are not strictly equal we approximate an answer
+
+        let xNumerator = boxedRationalNumerator(x)
+        let xDenominator = boxedRationalDenominator(x)
+        let yNumerator = boxedRationalNumerator(y)
+        let yDenominator = boxedRationalDenominator(y)
+
+        if (
+          BI.cmp(xNumerator, yNumerator) == 0n &&
+          BI.cmp(xDenominator, yDenominator) == 0n
+        ) {
+          0n
+        } else {
+          let xf = WasmF64.div(
+            BI.toFloat64(xNumerator),
+            BI.toFloat64(xDenominator)
+          )
+          let yf = WasmF64.div(
+            BI.toFloat64(yNumerator),
+            BI.toFloat64(yDenominator)
+          )
+          if (WasmF64.lt(xf, yf)) -1n else 1n
+        }
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
+        WasmI32.sub(0n, cmpFloat(y, x, false, totalOrdering))
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
+        WasmI32.sub(0n, cmpFloat(y, x, true, totalOrdering))
+      },
+      _ => {
+        throw UnknownNumberTag
+      },
     }
   }
 }
 
 @unsafe
-export let (>=) = (x: Number, y: Number) => {
-  let xw32 = WasmI32.fromGrain(x)
-  let yw32 = WasmI32.fromGrain(y)
-  if (isBigInt(xw32)) {
-    WasmI32.leS(cmpBigInt(xw32, yw32), 0n)
-  } else if (isBigInt(yw32)) {
-    WasmI32.geS(cmpBigInt(yw32, xw32), 0n)
-  } else {
-    // Equality is finicky, so delegate
-    let xval = coerceNumberToWasmF64(x)
-    let yval = coerceNumberToWasmF64(y)
-    if (WasmF64.gt(xval, yval)) {
-      true
+export let cmp = (x: WasmI32, y: WasmI32, totalOrdering: Bool) => {
+  if (isSimpleNumber(x)) {
+    if (isSimpleNumber(y)) {
+      if (WasmI32.ltS(x, y)) -1n else if (WasmI32.gtS(x, y)) 1n else 0n
     } else {
-      let x = WasmI32.fromGrain(x)
-      let y = WasmI32.fromGrain(y)
-      numberEqual(x, y)
+      let yBoxedNumberTag = boxedNumberTag(y)
+      match (yBoxedNumberTag) {
+        t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
+          WasmI32.sub(0n, cmpSmallInt(y, x, false, totalOrdering))
+        },
+        t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
+          WasmI32.sub(0n, cmpSmallInt(y, x, true, totalOrdering))
+        },
+        t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+          WasmI32.sub(0n, cmpBigInt(y, x))
+        },
+        t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
+          WasmI32.sub(0n, cmpRational(y, x, totalOrdering))
+        },
+        t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
+          WasmI32.sub(0n, cmpFloat(y, x, false, totalOrdering))
+        },
+        t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
+          WasmI32.sub(0n, cmpFloat(y, x, true, totalOrdering))
+        },
+        _ => {
+          throw UnknownNumberTag
+        },
+      }
+    }
+  } else {
+    let xBoxedNumberTag = boxedNumberTag(x)
+    match (xBoxedNumberTag) {
+      t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
+        cmpSmallInt(x, y, false, totalOrdering)
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
+        cmpSmallInt(x, y, true, totalOrdering)
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        cmpBigInt(x, y)
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
+        cmpRational(x, y, totalOrdering)
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
+        cmpFloat(x, y, false, totalOrdering)
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
+        cmpFloat(x, y, true, totalOrdering)
+      },
+      _ => {
+        throw UnknownNumberTag
+      },
     }
   }
 }
 
+@unsafe
+export let (<) = (x: Number, y: Number) => {
+  let x = WasmI32.fromGrain(x)
+  let y = WasmI32.fromGrain(y)
+  WasmI32.ltS(cmp(x, y, false), 0n)
+}
+
+@unsafe
+export let (>) = (x: Number, y: Number) => {
+  let x = WasmI32.fromGrain(x)
+  let y = WasmI32.fromGrain(y)
+  WasmI32.gtS(cmp(x, y, false), 0n)
+}
+
+@unsafe
+export let (<=) = (x: Number, y: Number) => {
+  let x = WasmI32.fromGrain(x)
+  let y = WasmI32.fromGrain(y)
+  WasmI32.leS(cmp(x, y, false), 0n)
+}
+
+@unsafe
+export let (>=) = (x: Number, y: Number) => {
+  let x = WasmI32.fromGrain(x)
+  let y = WasmI32.fromGrain(y)
+  WasmI32.geS(cmp(x, y, false), 0n)
+}
+
+@unsafe
+export let compare = (x: Number, y: Number) => {
+  let x = WasmI32.fromGrain(x)
+  let y = WasmI32.fromGrain(y)
+  WasmI32.toGrain(tagSimple(cmp(x, y, true))): Number
+}
+
 /*
  * ===== EQUAL =====
  */
@@ -1811,7 +2072,7 @@ export let numberEq = (x: Number, y: Number) => {
  * ===== LOGICAL OPERATIONS =====
  * Only valid for int-like numbers. Coerce to i64/bigInt and do operations
  */
-// TODO: (#306) Semantics around when things should stay i32/i64
+// TODO(#306): Semantics around when things should stay i32/i64
 
 @unsafe
 export let lnot = (x: Number) => {
@@ -1833,7 +2094,15 @@ export let (<<) = (x: Number, y: Number) => {
   } else {
     let xval = coerceNumberToWasmI64(x)
     let yval = coerceNumberToWasmI64(y)
-    WasmI32.toGrain(reducedInteger(WasmI64.shl(xval, yval))): Number
+    // if the number will be shifted beyond the end of the i64 range, promote to BigInt
+    // (note that we subtract one leading zero, since the leading bit is the sign bit)
+    if (WasmI64.leU(WasmI64.sub(WasmI64.clz(i64abs(xval)), 1N), yval)) {
+      let xbi = coerceNumberToBigInt(x)
+      let yval = coerceNumberToWasmI32(y)
+      WasmI32.toGrain(reducedBigInteger(BI.shl(xbi, yval))): Number
+    } else {
+      WasmI32.toGrain(reducedInteger(WasmI64.shl(xval, yval))): Number
+    }
   }
 }
 
@@ -2220,3 +2489,57 @@ export let isBigInt = x => {
   let x = WasmI32.fromGrain(x)
   isBigInt(x)
 }
+
+// Scalbn is based on https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c
+/*
+ * ====================================================
+ * Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+/**
+ * Multiplies a floating-point number by an integral power of 2.
+ *
+ * @param x: The floating-point value
+ * @param n: The Integer exponent
+ * @returns The result of x * 2^n
+ *
+ * @since v0.5.4
+ */
+@unsafe
+export let scalbn = (x, n) => {
+  let (>) = WasmI32.gtS
+  let (<) = WasmI32.ltS
+  let (*) = WasmF64.mul
+  let (-) = WasmI32.sub
+  let (+) = WasmI32.add
+  let (<<) = WasmI64.shl
+  // Constants
+  let const_0x1p1023 = 8.98847e+307W
+  let const_0x1p_1022 = 2.22507e-308W
+  let const_0x1p53 = 9.0072e+15W
+  let mut n = n
+  let mut y = x
+  if (n > 1023n) {
+    y *= const_0x1p1023
+    n -= 1023n
+    if (n > 1023n) {
+      y *= const_0x1p1023
+      n -= 1023n
+      if (n > 1023n) n = 1023n
+    } else if (n < -1023n) {
+      /* make sure final n < -53 to avoid double rounding in the subnormal range */
+      y *= const_0x1p_1022 * const_0x1p53
+      n += 1022n - 53n
+      if (n < -1022n) {
+        y *= const_0x1p_1022 * const_0x1p53
+        n += 1022n - 53n
+        if (n < -1022n) n = -1022n
+      }
+    }
+  }
+  y * WasmF64.reinterpretI64(WasmI64.extendI32S(0x3FFn + n) << 52N)
+}