@temperlang/core 0.5.0 → 0.6.0

package/check-type.js

@@ -27,17 +27,6 @@ export const requireInstanceOf = (x, typeRequirement) => {
 export const requireNotNull = (x) =>
   x == null ? bubble() : x
 
-/**
- * @param {number} x
- * @returns {number}
- */
-export const requireIsSafeInteger = (x) => {
-  if (!Number.isSafeInteger(x)) {
-    bubble();
-  }
-  return x;
-};
-
 /**
  * @template X, Y
  * @param {X} x

package/core.js

@@ -1,3 +1,4 @@
+// @ts-check
 
 /**
  * @param {number} x
@@ -10,7 +11,7 @@ export const divIntInt = (x, y) => {
     bubble();
   }
   /* not NaN or infinite */
-  return result;
+  return result | 0;
 };
 
 /**
@@ -25,9 +26,137 @@ export const modIntInt = (x, y) => {
     bubble();
   }
   /* not NaN or infinite */
-  return result;
+  return result | 0;
 };
 
+/**
+ * @param {string} s
+ * @param {(number | bigint)?} radix
+ * @returns {bigint}
+ */
+export const parseBigInt = (s, radix) => {
+    const rdx = BigInt(radix ?? 10);
+    let result = 0n;
+    // TODO Definitions of whitespace? Better to check /\s/ on the fly?
+    s = s.trim();
+    let i = 0;
+    let sign = 1n;
+    if (s.startsWith("-")) {
+      i++;
+      sign = -1n;
+    }
+    for (; i < s.length; i++) {
+      const c = s.charCodeAt(i);
+      /** @type {bigint} */
+      let digit;
+      if (c >= c0 && c <= c9) {
+        digit = BigInt(c - c0);
+      } else if (c >= cA && c <= cZ) {
+        digit = BigInt(c - cA + 10);
+      } else if (c >= ca && c <= cz) {
+        digit = BigInt(c - ca + 10);
+      } else {
+        bubble();
+      }
+      if (digit >= rdx) {
+        bubble();
+      }
+      result = result * rdx + digit;
+    }
+    return sign * result;
+};
+
+const c0 = "0".charCodeAt(0);
+const c9 = "9".charCodeAt(0);
+const cA = "A".charCodeAt(0);
+const cZ = "Z".charCodeAt(0);
+const ca = "a".charCodeAt(0);
+const cz = "z".charCodeAt(0);
+
+export const INT32_MAX = (2 ** 31) - 1;
+export const INT32_MIN = -(2 ** 31);
+export const INT64_MAX = (2n ** 63n) - 1n;
+export const INT64_MIN = -(2n ** 63n);
+
+// Related to int64 limits above.
+const edge64 = 1n << 64n;
+
+/**
+ * @param {bigint} x
+ * @returns {bigint}
+ */
+export const clampInt64 = (x) => {
+  x = x % edge64;
+  if (x > INT64_MAX) {
+    x -= edge64;
+  } else if (x < INT64_MIN) {
+    x += edge64;
+  }
+  return x;
+};
+
+/**
+ * Implements extension method Int64::max
+ * @param {bigint} a
+ * @param {bigint} b
+ * @returns {bigint}
+ */
+export const int64Max = (a, b) => {
+  return a > b ? a : b;
+}
+
+/**
+ * Implements extension method Int64::min
+ * @param {bigint} a
+ * @param {bigint} b
+ * @returns {bigint}
+ */
+export const int64Min = (a, b) => {
+  return a < b ? a : b;
+}
+
+/**
+ * Implements extension method Int64::toInt32
+ * @param {bigint} n
+ * @returns {number}
+ */
+export const int64ToInt32 = (n) => {
+  if (n < INT32_MIN || n > INT32_MAX) {
+    bubble();
+  }
+  return int64ToInt32Unsafe(n);
+}
+
+/**
+ * Implements extension method Int64::toInt32Unsafe
+ * @param {bigint} n
+ * @returns {number}
+ */
+export const int64ToInt32Unsafe = (n) => {
+  return Number(n) | 0;
+}
+
+/**
+ * Implements extension method Int64::toFloat64
+ * @param {bigint} n
+ * @returns {number}
+ */
+export const int64ToFloat64 = (n) => {
+  if (n < Number.MIN_SAFE_INTEGER || n > Number.MAX_SAFE_INTEGER) {
+    bubble();
+  }
+  return Number(n);
+}
+
+/**
+ * Implements extension method Int64::toFloat63Unsafe
+ * @param {bigint} n
+ * @returns {number}
+ */
+export const int64ToFloat64Unsafe = (n) => {
+  return Number(n);
+}
+
 /**
  * Compare two Strings.
  * @param {string} a
@@ -64,9 +193,11 @@ export const cmpFloat = (a, b) => {
     return 0;
   }
   if (a === b) {
+    // @ts-ignore
     return Object.is(a, 0) - Object.is(b, 0);
   }
   if (isNaN(a) || isNaN(b)) {
+    // @ts-ignore
     return isNaN(a) - isNaN(b);
   }
   return a - b;
@@ -86,6 +217,7 @@ export const cmpGeneric = (a, b) => {
     return cmpFloat(a, b);
   }
   if (typeof a === "boolean" && typeof b === "boolean") {
+    // @ts-ignore
     return a - b;
   }
   bubble();
@@ -121,7 +253,8 @@ export const print = (a) => {
  * @return any
  */
 export let marshalToJsonObject = (jsonAdapter, value) => {
-  let stack = [[]];
+  /** @type {any[]} */
+  const stack = [[]];
   let pendingKey = null;
   function store(value) {
     let top = stack[stack.length - 1];
@@ -154,7 +287,7 @@ export let marshalToJsonObject = (jsonAdapter, value) => {
 
     nullValue() { store(null); },
     booleanValue(b) { store(!!b); },
-    intValue(v) { store(Math.trunc(v)); },
+    int32Value(v) { store(Math.trunc(v)); },
     float64Value(v) { store(+v); },
     numericTokenValue(s) { store(+s); },
     stringValue(s) { store(`${s}`); },

package/float.js

@@ -1,6 +1,7 @@
+// @ts-check
 
 // Implements extension method Float64::near
-import {bubble} from "./core.js";
+import {bubble, INT32_MAX, INT32_MIN, INT64_MAX, INT64_MIN} from "./core.js";
 
 /**
  * Implements extension method Float64::near
@@ -22,12 +23,12 @@ export const float64Near = (x, y, relTol, absTol) => {
 }
 
 /**
- * Implements extension method Float64::toInt
+ * Implements extension method Float64::toInt32
  * @param {number} n
  * @returns {number}
  */
-export const float64ToInt = (n) => {
-  const i = float64ToIntUnsafe(n);
+export const float64ToInt32 = (n) => {
+  const i = float64ToInt32Unsafe(n);
   if (Math.abs(n - i) < 1) {
     return i;
   } else {
@@ -36,20 +37,49 @@ export const float64ToInt = (n) => {
 }
 
 /**
- * Implements extension method Float64::toIntUnsafe
+ * Implements extension method Float64::toInt32Unsafe
  * @param {number} n
  * @returns {number}
  */
-export const float64ToIntUnsafe = (n) => {
+export const float64ToInt32Unsafe = (n) => {
   // We are free to do whatever with NaN here.
   return isNaN(n)
     ? 0
     : Math.max(
-      Number.MIN_SAFE_INTEGER,
-      Math.min(Math.trunc(n), Number.MAX_SAFE_INTEGER)
+      INT32_MIN,
+      Math.min(Math.trunc(n), INT32_MAX)
     );
 }
 
+/**
+ * Implements extension method Float64::toInt64
+ * @param {number} n
+ * @returns {bigint}
+ */
+export const float64ToInt64 = (n) => {
+  // Also blocks NaNs.
+  if (!(n >= Number.MIN_SAFE_INTEGER && n <= Number.MAX_SAFE_INTEGER)) {
+    bubble();
+  }
+  return float64ToInt64Unsafe(n);
+}
+
+/**
+ * Implements extension method Float64::toInt64Unsafe
+ * @param {number} n
+ * @returns {bigint}
+ */
+export const float64ToInt64Unsafe = (n) => {
+  // We are free to do whatever with NaN here.
+  return isNaN(n)
+    ? 0n
+    : BigInt(Math.max(
+      // Avoid converting giant numbers to bigint.
+      Number(INT64_MIN),
+      Math.min(Math.trunc(n), Number(INT64_MAX)),
+    ));
+}
+
 /**
  * Implements extension method Float64::toString
  * @param {number} n

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@temperlang/core",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Runtime support for JS generated by Temper",
   "main": "index.js",
   "type": "module",
   "author": "https://github.com/mikesamuel",
-  "license": "Apache-2.0"
+  "license": "Apache-2.0 OR MIT"
 }

package/string.js

@@ -1,5 +1,6 @@
-import { requireIsSafeInteger } from "./check-type.js";
-import {bubble} from "./core.js";
+import {
+    bubble, INT32_MAX, INT32_MIN, INT64_MAX, INT64_MIN, parseBigInt
+} from "./core.js";
 
 /**
  * Implements extension method String::fromCodePoint
@@ -57,20 +58,38 @@ export const stringToFloat64 = (s) => {
 };
 
 /**
- * Implements extension method String::toInt
+ * Implements extension method String::toInt32
  * @param {string} s
  * @param {number?} radix
  * @returns {number}
  */
-export const stringToInt = (s, radix) => {
+export const stringToInt32 = (s, radix) => {
     // This currently maybe allocates for trim and then also for check.
     // TODO Avoid that with manual char checks? Arbitrary base makes regex harder.
     s = s.trim();
     radix = radix ?? 10;
     const result = parseInt(s, radix);
-    requireIsSafeInteger(result);
+    // This check also catches nan.
+    if (!(result >= INT32_MIN && result <= INT32_MAX)) {
+        bubble();
+    }
     const trimmed = s.slice(0, s.length - 1);
     if (parseInt(trimmed, radix) === result) {
+        // Extraneous junk was ignored that we disallow.
+        bubble();
+    }
+    return result;
+};
+
+/**
+ * Implements extension method String::toInt64
+ * @param {string} s
+ * @param {number?} radix
+ * @returns {number}
+ */
+export const stringToInt64 = (s, radix) => {
+    const result = parseBigInt(s, radix);
+    if (result < INT64_MIN || result > INT64_MAX) {
         bubble();
     }
     return result;
@@ -164,6 +183,25 @@ export const stringPrev = (s, i) => {
     return iPrev;
 };
 
+/**
+ * @param {string} s
+ * @param {number} i
+ * @param {number} by
+ * @returns {number}
+ */
+export const stringStep = (s, i, by) => {
+    let step = by >= 0 ? stringNext : stringPrev;
+    by = Math.abs(by);
+    for (let j = 0; j < by; j += 1) {
+        const iOld = i;
+        i = step(s, i);
+        if (i == iOld) {
+            break;
+        }
+    }
+    return i;
+};
+
 /**
  * @param {string} s
  * @param {(number) => void} f
@@ -218,4 +256,4 @@ const denySurrogate = (c) => {
     if (c >= 0xD800 && c <= 0xDFFF) {
         throw new RangeError(`Invalid Unicode scalar value ${c}`)
     }
-}
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+    "compilerOptions": {
+        "allowJs": true,
+        "noEmit": true,
+        "preserveConstEnums": false,
+        "removeComments": true,
+        "sourceMap": false,
+        "target": "es2020"
+    },
+    "files": [
+        "async.js",
+        "bitvector.js",
+        "check-type.js",
+        "core.js",
+        "date.js",
+        "deque.js",
+        "float.js",
+        "index.js",
+        "interface.js",
+        "listed.js",
+        "mapped.js",
+        "pair.js",
+        "regex.js",
+        "string.js"
+    ]
+}