@temperlang/core 0.4.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();
@@ -98,6 +230,13 @@ export const bubble = () => {
   throw Error();
 };
 
+/**
+ * TODO Distinguish panic from bubble.
+ *
+ * @returns {never}
+ */
+export const panic = bubble;
+
 /**
  * @template T
  * @param {T} a
@@ -105,3 +244,76 @@ export const bubble = () => {
 export const print = (a) => {
   console.log("%s", a);
 };
+
+/**
+ * Takes a JSON adapter and a value that it can adapt.
+ * This is called when JavaScript code calls JSON.stringify on a Temper type instance
+ * that has a zero argument jsonAdapter static method.
+ *
+ * @return any
+ */
+export let marshalToJsonObject = (jsonAdapter, value) => {
+  /** @type {any[]} */
+  const stack = [[]];
+  let pendingKey = null;
+  function store(value) {
+    let top = stack[stack.length - 1];
+    if (pendingKey !== null) {
+      top[pendingKey] = value;
+      pendingKey = null;
+    } else if (Array.isArray(top)) {
+      top.push(value);
+    } else {
+      throw new Error();
+    }
+  }
+  let jsonProducer = {
+    interchangeContext: { getHeader() { return null; } },
+
+    startObject() {
+      let o = {};
+      store(o);
+      stack.push(o);
+    },
+    endObject() { stack.pop(); },
+    objectKey(key) { pendingKey = String(key); },
+
+    startArray() {
+      let a = [];
+      store(a);
+      stack.push(a);
+    },
+    endArray() { stack.pop(); },
+
+    nullValue() { store(null); },
+    booleanValue(b) { store(!!b); },
+    int32Value(v) { store(Math.trunc(v)); },
+    float64Value(v) { store(+v); },
+    numericTokenValue(s) { store(+s); },
+    stringValue(s) { store(`${s}`); },
+
+    parseErrorReceiver: null,
+  }
+  jsonAdapter.encodeToJson(value, jsonProducer);
+  return stack[0][0];
+};
+
+/** @type {{}} */
+let emptySingleton = Object.freeze(
+  // Prototype for empty
+  Object.create(
+    Object.freeze(
+      Object.create(
+        null,
+        {
+          toString: {
+            value: function toString() { return "(empty)" }
+          }
+        }
+      )
+    )
+  )
+);
+
+/** @return {{}} */
+export function empty() { return emptySingleton }

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/index.js

@@ -8,6 +8,7 @@ export * from "./float.js";
 export * from "./interface.js";
 export * from "./listed.js";
 export * from "./mapped.js";
+export * from "./net.js";
 export * from "./pair.js";
 export * from "./regex.js";
 export * from "./string.js";

package/interface.js

@@ -37,7 +37,7 @@ export const type = (...superTypes) => {
 
   class Union {
     static [Symbol.hasInstance] = (instance) => {
-      return key in instance;
+      return typeof instance === 'object' && instance !== null && key in instance;
     };
   }
 

package/mapped.js

@@ -156,7 +156,7 @@ export const mappedHas = (map, key) => {
  * @returns {Readonly<K[]>}
  */
 export const mappedKeys = (map) => {
-  return Object.freeze(Array.prototype.slice.call(map.keys()));
+  return Object.freeze(Array.from(map.keys()));
 }
 
 /**
@@ -165,7 +165,7 @@ export const mappedKeys = (map) => {
  * @returns {Readonly<V[]>}
  */
 export const mappedValues = (map) => {
-  return Object.freeze(Array.prototype.slice.call(map.values()));
+  return Object.freeze(Array.from(map.values()));
 }
 
 /**

package/net.js

@@ -0,0 +1,41 @@
+/**
+ * @param {string} url
+ * @param {"GET" | "POST"} method
+ * @param {string | null} bodyContent
+ * @param {string | null} bodyMimeType
+ * @return {Promise<Response>}
+ */
+export function stdNetSend(url, method, bodyContent, bodyMimeType) {
+  let details = { method };
+  if (typeof bodyContent === 'string') {
+    details.body = bodyContent;
+    if (typeof bodyMimeType === 'string') {
+      details.headers = { 'Content-Type': bodyMimeType };
+    }
+  }
+  return fetch(url, details);
+}
+
+/**
+ * @param {Response} r
+ * @return {number} an HTTP status code
+ */
+export function netResponseGetStatus(r) {
+  return r.status;
+}
+
+/**
+ * @param {Response} r
+ * @return {string | null} the mime-type of the body.
+ */
+export function netResponseGetContentType(r) {
+  return r.headers.get('Content-Type') || null;
+}
+
+/**
+ * @param {Response} r
+ * @return {Promise<string | null>} the body content.
+ */
+export function netResponseGetBodyContent(r) {
+  return r.text();
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@temperlang/core",
-  "version": "0.4.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/regex.js

@@ -108,7 +108,7 @@ export const regexCompiledSplit = (_, compiled, text) => {
 };
 
 /**
- * @param {RegExp} _
+ * @param {unknown} _
  * @param {string} formatted
  * @returns {RegExp}
  */
@@ -139,10 +139,16 @@ export const regexFormatterAdjustCodeSet = (self, codeSet, regexRefs) => {
   return codeSet;
 };
 
+/**
+ * @param {unknown} _
+ * @param {[string]} out
+ * @param {number} code
+ * @param {boolean} insideCodeSet
+ */
 export const regexFormatterPushCodeTo = (_, out, code, insideCodeSet) => {
   // Ignore insideCodeSet for now.
   // TODO(tjp, regex): Get fancier, including with work in Temper.
-  out.push(`\\u{${code.toString(16)}}`);
+  out[0] += `\\u{${code.toString(16)}}`;
 };
 
 // Cached later for some approximate efficiency.

package/string.js

@@ -1,5 +1,16 @@
-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
+ * @param {number} codePoint
+ * @returns {string}
+ */
+export const stringFromCodePoint = (codePoint) => {
+    denySurrogate(codePoint);
+    return String.fromCodePoint(codePoint);
+};
 
 /**
  * Implements extension method String::fromCodePoints
@@ -7,6 +18,9 @@ import {bubble} from "./core.js";
  * @returns {string}
  */
 export const stringFromCodePoints = (codePoints) => {
+    for (const codePoint of codePoints) {
+        denySurrogate(codePoint);
+    }
     // TODO Append in batches if codePoints is long?
     return String.fromCodePoint(...codePoints);
 };
@@ -44,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;
@@ -151,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
@@ -194,5 +245,15 @@ export const requireNoStringIndex = (i) => {
  * @param {number} c
  */
 export const stringBuilderAppendCodePoint = (s, c) => {
+    denySurrogate(c);
     s[0] += String.fromCodePoint(c);
 }
+
+/**
+ * @param {number} c
+ */
+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"
+    ]
+}