@temperlang/core 0.0.3 → 0.0.4

package/index.js

@@ -1,16 +1,16 @@
-export * from './interface-types.js';
-export * from './regex.js';
+export * from "./interface-types.js";
+export * from "./regex.js";
 
-export const noResultException = new (
-  class NoResultException extends Error {
-    constructor() {
-      super("NoResult");
-    }
+export const noResultException = new (class NoResultException extends Error {
+  constructor() {
+    super("NoResult");
   }
-);
+})();
 
 // Implements extension method String::isEmpty
-export function stringIsEmpty(s) { return s === ''; }
+export function stringIsEmpty(s) {
+  return s === "";
+}
 // Implements extension method String::split
 export function stringSplit(s, separator) {
   return s.split(separator).map((s) => s);
@@ -18,18 +18,16 @@ export function stringSplit(s, separator) {
 
 /** Specifically for utf8 and utf32, since utf16 is simpler in js. */
 class TrickyStringSlice {
-  #length;
-
   hasAtLeast(count) {
     // Repeated calls to hasAtLeast are potentially expensive.
-    return (this.#length ?? this._lengthUntil(count)) >= count;
+    return (this.length ?? this._lengthUntil(count)) >= count;
   }
 
   get length() {
-    if (this.#length === undefined) {
-      this.#length = this._lengthUntil();
+    if (this._length === undefined) {
+      this._length = this._lengthUntil();
     }
-    return this.#length;
+    return this._length;
   }
 
   _lengthUntil(stop = undefined) {
@@ -39,62 +37,58 @@ class TrickyStringSlice {
 }
 
 class Utf8StringSlice extends TrickyStringSlice {
-  /** The underlying string value. */
-  #content;
-  /**
-   * The byte index approximation of the left side.
-   * A byte index approximation is an integer, i, such that:
-   * - (i >> 2) is the index of a codepoint in #content
-   * - (i & 3)  is the index of a byte within the UTF-8 representation of that codepoint.
-   */
-  #left;
-  /** The byte index approximation of the right side. */
-  #right;
-
   constructor(content, left = 0, right = content.length * 4) {
     super();
-    this.#content = content;
-    this.#left = left;
-    this.#right = right;
+    this.content = content;
+    this.left = left;
+    this.right = right;
   }
 
   toString() {
-    let left = this.#left;
-    let right = this.#right;
-    let content = this.#content;
+    let left = this.left;
+    let right = this.right;
+    let content = this.content;
 
-    if (left === right) { return ""; }
+    if (left === right) {
+      return "";
+    }
 
     // If we're only using some bytes on the left or right, replace that codepoint with U+FFFD.
     let leftPartial = left & 3; // Do we have an incomplete code-point on the left?
     let leftIndex = (left + 3) >> 2;
     let rightIndex = right >> 2;
-    let rightPartial = (right & 3);
+    let rightPartial = right & 3;
 
     // If leftIndex is in the middle of a surrogate pair, advance over the tail.
     if (leftIndex < rightIndex) {
       let leftCodeUnitUtf16 = content.charCodeAt(leftIndex);
-      if (0xDC00 < leftCodeUnitUtf16 && leftCodeUnitUtf16 <= 0xDFFF) {
+      if (0xdc00 < leftCodeUnitUtf16 && leftCodeUnitUtf16 <= 0xdfff) {
         leftIndex += 1;
       }
     }
 
-    if (leftIndex > rightIndex) { return "\uFFFD"; }
+    if (leftIndex > rightIndex) {
+      return "\uFFFD";
+    }
 
     let sub = content.substring(leftIndex, rightIndex);
     if (leftPartial || rightPartial) {
-      return `${leftPartial ? "\uFFFD" : ""}${sub}${rightPartial ? "\uFFFD" : ""}`
+      return `${leftPartial ? "\uFFFD" : ""}${sub}${
+        rightPartial ? "\uFFFD" : ""
+      }`;
     } else {
       return sub;
     }
   }
 
-  valueOf() { return this.toString(); }
+  valueOf() {
+    return this.toString();
+  }
 
   _lengthUntil(stop) {
-    const left = this.#left;
-    const right = this.#right;
-    const content = this.#content;
+    const left = this.left;
+    const right = this.right;
+    const content = this.content;
     let i = left >> 2;
     // Add bytes between codePointBoundaryBeforeLimit and right
     // Subtract bytes past zeroth in codepoint for left
@@ -113,17 +107,17 @@ class Utf8StringSlice extends TrickyStringSlice {
   }
 
   get isEmpty() {
-    return this.#left >= this.#right;
+    return this.left >= this.right;
   }
 
   read() {
-    let left = this.#left;
-    let right = this.#right;
+    let left = this.left;
+    let right = this.right;
     if (left >= right) {
       throw noResultException;
     }
 
-    let content = this.#content;
+    let content = this.content;
     let cp = content.codePointAt(left >> 2);
     if (cp < 0x80) {
       return cp;
@@ -131,7 +125,8 @@ class Utf8StringSlice extends TrickyStringSlice {
       let byteOffset = left & 3;
       let nBytes = nUtf8BytesInChar(cp);
       let byteInfo = byteInfos[(nBytes - 1) * 4 + byteOffset];
-      let codeUnit = ((cp >>> byteInfo.shift) & byteInfo.andMask) | byteInfo.orMask;
+      let codeUnit =
+        ((cp >>> byteInfo.shift) & byteInfo.andMask) | byteInfo.orMask;
       return codeUnit;
     }
   }
@@ -140,12 +135,12 @@ class Utf8StringSlice extends TrickyStringSlice {
     if (count <= 0) {
       return this;
     } else if (count === 1) {
-      let left = this.#left;
-      let right = this.#right;
+      let left = this.left;
+      let right = this.right;
       if (left >= right) {
         return this;
       }
-      let content = this.#content;
+      let content = this.content;
       let cp = content.codePointAt(left >> 2);
       let newLeft;
       if (cp < 0x80) {
@@ -153,7 +148,10 @@ class Utf8StringSlice extends TrickyStringSlice {
       } else {
         let byteOffset = left & 3;
         let nBytes = nUtf8BytesInChar(cp);
-        newLeft = (byteOffset + 1 < nBytes) ? left + 1 : (left & ~3) + ((nBytes + 4) & ~3);
+        newLeft =
+          byteOffset + 1 < nBytes
+            ? left + 1
+            : (left & ~3) + ((nBytes + 4) & ~3);
       }
       return new Utf8StringSlice(content, newLeft, right);
     } else {
@@ -162,7 +160,7 @@ class Utf8StringSlice extends TrickyStringSlice {
   }
 
   [Symbol.iterator]() {
-    function *bytes(content, left, limit) {
+    function* bytes(content, left, limit) {
       let i = left;
       while (i < limit) {
         let cp = content.codePointAt(i >> 2);
@@ -173,127 +171,115 @@ class Utf8StringSlice extends TrickyStringSlice {
           let byteOffset = i & 3;
           let nBytes = nUtf8BytesInChar(cp);
           let byteInfo = byteInfos[(nBytes - 1) * 4 + byteOffset];
-          let codeUnit = ((cp >>> byteInfo.shift) & byteInfo.andMask) | byteInfo.orMask;
+          let codeUnit =
+            ((cp >>> byteInfo.shift) & byteInfo.andMask) | byteInfo.orMask;
           yield codeUnit;
-          i = (byteOffset + 1 < nBytes) ? i + 1 : (i & ~3) + ((nBytes + 4) & ~3);
+          i = byteOffset + 1 < nBytes ? i + 1 : (i & ~3) + ((nBytes + 4) & ~3);
         }
       }
     }
-    return bytes(this.#content, this.#left, this.#right);
+    return bytes(this.content, this.left, this.right);
   }
 
   toJSON() {
-    return { content: this.#content, left: this.#left, right: this.#right };
+    return { content: this.content, left: this.left, right: this.right };
   }
 }
 
 class Utf16StringSlice {
-  /** The underlying string value. */
-  #content;
-  /**
-   * A regular character offset of the left of the slice, inclusive.
-   */
-  #left;
-  /** A regular character offset of the right of the slice, exclusive. */
-  #right;
-
   constructor(content, left = 0, right = content.length) {
-    this.#content = content;
-    this.#left = left;
-    this.#right = right;
+    this.content = content;
+    this.left = left;
+    this.right = right;
   }
 
   toString() {
-    return this.#content.substring(this.#left, this.#right);
+    return this.content.substring(this.left, this.right);
   }
 
-  valueOf() { return this.toString(); }
+  valueOf() {
+    return this.toString();
+  }
 
   hasAtLeast(count) {
     return this.length >= count;
   }
 
   get length() {
-    return this.#right - this.#left;
+    return this.right - this.left;
   }
 
   get isEmpty() {
-    return this.#left >= this.#right;
+    return this.left >= this.right;
   }
 
   read() {
-    let left = this.#left;
-    let right = this.#right;
-    if (left >= right) { throw noResultException; }
-    return this.#content.charCodeAt(left);
+    let left = this.left;
+    let right = this.right;
+    if (left >= right) {
+      throw noResultException;
+    }
+    return this.content.charCodeAt(left);
   }
 
   advance(count) {
     if (count <= 0) {
       return this;
     } else {
-      let left = this.#left;
-      let right = this.#right;
+      let left = this.left;
+      let right = this.right;
       if (left >= right) {
         return this;
       }
       let newLeft = left + count;
-      if (newLeft >= right) { newLeft = right; }
-      return new Utf16StringSlice(this.#content, newLeft, right);
+      if (newLeft >= right) {
+        newLeft = right;
+      }
+      return new Utf16StringSlice(this.content, newLeft, right);
     }
   }
 
   [Symbol.iterator]() {
-    function *chars(content, left, limit) {
+    function* chars(content, left, limit) {
       let i = left;
       while (i < limit) {
-        yield content.charCodeAt(i)
-        i += 1
+        yield content.charCodeAt(i);
+        i += 1;
       }
     }
-    return chars(this.#content, this.#left, this.#right);
+    return chars(this.content, this.left, this.right);
   }
 
   toJSON() {
-    return { content: this.#content, left: this.#left, right: this.#right };
+    return { content: this.content, left: this.left, right: this.right };
   }
 }
 
 class CodePointsStringSlice extends TrickyStringSlice {
-  /** The underlying string value. */
-  #content;
-  /**
-   * A regular character offset of the left of the slice, inclusive.
-   */
-  #left;
-  /** A regular character offset of the right of the slice, exclusive. */
-  #right;
-
   constructor(content, left = 0, right = content.length) {
     super();
-    this.#content = content;
-    this.#left = left;
-    this.#right = right;
+    this.content = content;
+    this.left = left;
+    this.right = right;
   }
 
   toString() {
-    return this.#content.substring(this.#left, this.#right);
+    return this.content.substring(this.left, this.right);
   }
 
-  valueOf() { return this.toString(); }
+  valueOf() {
+    return this.toString();
+  }
 
   _lengthUntil(stop) {
-    const left = this.#left;
-    const right = this.#right;
-    const content = this.#content;
-    let i = left;
+    let i = this.left;
     let len = 0;
-    while (i < right) {
+    while (i < this.right) {
       if (stop !== undefined && len >= stop) {
         break;
       }
-      let cp = content.codePointAt(i);
-      if (cp > 0xFFFF) {
+      let cp = this.content.codePointAt(i);
+      if (cp > 0xffff) {
         i += 2;
       } else {
         i += 1;
@@ -304,58 +290,59 @@ class CodePointsStringSlice extends TrickyStringSlice {
   }
 
   get isEmpty() {
-    return this.#left >= this.#right;
+    return this.left >= this.right;
   }
 
   read() {
-    let left = this.#left;
-    let right = this.#right;
-    if (left >= right) { throw noResultException; }
-    return this.#content.codePointAt(left);
+    if (this.left >= this.right) {
+      throw noResultException;
+    }
+    return this.content.codePointAt(this.left);
   }
 
   advance(count) {
     if (count <= 0) {
       return this;
     } else {
-      let left = this.#left;
-      let right = this.#right;
-      let content = this.#content;
+      let left = this.left;
+      let right = this.right;
+      let content = this.content;
       if (left >= right) {
         return this;
       }
       let newLeft = left;
       for (let i = count; i && newLeft < right; --i) {
         let cp = content.codePointAt(newLeft);
-        if (cp > 0xFFFF) {
+        if (cp > 0xffff) {
           newLeft += 2;
         } else {
           newLeft += 1;
         }
       }
-      if (newLeft >= right) { newLeft = right; }
-      return new CodePointsStringSlice(this.#content, newLeft, right);
+      if (newLeft >= right) {
+        newLeft = right;
+      }
+      return new CodePointsStringSlice(this.content, newLeft, right);
     }
   }
 
   [Symbol.iterator]() {
-    function *chars(content, left, limit) {
+    function* chars(content, left, limit) {
       let i = left;
       while (i < limit) {
         let cp = content.codePointAt(i);
         yield cp;
-        i += (cp > 0xFFFF) ? 2 : 1;
+        i += cp > 0xffff ? 2 : 1;
       }
     }
-    return chars(this.#content, this.#left, this.#right);
+    return chars(this.content, this.left, this.right);
   }
 
   toJSON() {
-    return { content: this.#content, left: this.#left, right: this.#right };
+    return { content: this.content, left: this.left, right: this.right };
   }
 }
 
-
 // Implements extension method String::utf8
 export function stringUtf8(string) {
   return new Utf8StringSlice(string);
@@ -376,33 +363,57 @@ export function intToString(i, radix) {
   return i.toString(radix);
 }
 
+// Implements extension method Float64::toInt
+export function float64ToInt(n) {
+  const i = float64ToIntUnsafe(n);
+  if (Math.abs(n - i) < 1) {
+    return i;
+  } else {
+    throw noResultException;
+  }
+}
+
+// Implements extension method Float64::toIntUnsafe
+export function float64ToIntUnsafe(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)
+      );
+}
+
 // Implements extension method Float64::toString
 export function float64ToString(n) {
   // TODO(mikesamuel, issue#579): need functional test to nail down
   // double formatting threshholds.
   switch (n) {
     case 0:
-      // differentiating negative zero from zero is a pain. Got this solution from
-      // https://dev.to/emnudge/identifying-negative-zero-2j1o
-      if (1 / n == Infinity) {
-        return "0.0"
-      }
-      else {
-        return "-0.0"
+      if (Object.is(n, -0)) {
+        return "-0.0";
+      } else {
+        return "0.0";
       }
     case Infinity:
-      return "∞"
+      return "∞";
     case Number.NEGATIVE_INFINITY:
-      return "-∞"
+      return "-∞";
     default:
-      return n.toString();
-  };
+      let result = n.toString();
+      // Rely on eagerness and js number formatting rules here.
+      const groups = /(-?[0-9]+)(\.[0-9]+)?(.+)?/.exec(result);
+      if (groups === null) {
+        return result;
+      } else {
+        // Guarantee a decimal point for floats.
+        return `${groups[1]}${groups[2] || ".0"}${groups[3] || ""}`;
+      }
+  }
 }
 
 function nUtf8BytesInChar(cp) {
-  return (cp < 0x0800)
-    ? ((cp < 0x80) ? 1 : 2)
-    : ((cp < 0x10000) ? 3 : 4)
+  return cp < 0x0800 ? (cp < 0x80 ? 1 : 2) : cp < 0x10000 ? 3 : 4;
 }
 
 /*
@@ -451,9 +462,7 @@ export function listBuilderAdd(ls, newItem, at) {
     }
     ls.splice(at, 0, newItem);
   }
-  return; // of type tVoid
 }
-
 // Implements extension method ListBuilder::addAll
 export function listBuilderAddAll(ls, newItems, at) {
   if (at === undefined) {
@@ -464,7 +473,6 @@ export function listBuilderAddAll(ls, newItems, at) {
     }
     ls.splice(at, 0, ...newItems);
   }
-  return; // of type tVoid
 }
 // Implements extension method List::filter
 export function listFilter(ls, predicate) {
@@ -494,13 +502,15 @@ export function listFilter(ls, predicate) {
 // Implements extension method List::get
 export function listGet(ls, i) {
   let { length } = ls;
-  if (0 <= i && i < length) { return ls[i]; }
+  if (0 <= i && i < length) {
+    return ls[i];
+  }
   throw noResultException;
 }
 // Implements extension method List::getOr
 export function listGetOr(ls, i, fallback) {
   let { length } = ls;
-  return (0 <= i && i < length) ? ls[i] : fallback;
+  return 0 <= i && i < length ? ls[i] : fallback;
 }
 // Implements extension method List::isEmpty
 export function listIsEmpty(ls) {
@@ -508,7 +518,7 @@ export function listIsEmpty(ls) {
 }
 // Implements extension method List::join
 export function listJoin(ls, separator, elementStringifier) {
-  let joined = '';
+  let joined = "";
   let { length } = ls;
   for (let i = 0; i < length; ++i) {
     if (i) {
@@ -521,9 +531,13 @@ export function listJoin(ls, separator, elementStringifier) {
   return joined;
 }
 // Implements extension method List::length
-export function listLength(ls) { return ls.length; }
+export function listLength(ls) {
+  return ls.length;
+}
 // Implements extension method List::mapDropping
-export function listMapDropping() { throw new Error("TODO List::mapDropping"); }
+export function listMapDropping() {
+  throw new Error("TODO List::mapDropping");
+}
 // Implements extension method List::map
 export function listMap(ls, transform) {
   let mapped = [];
@@ -534,6 +548,14 @@ export function listMap(ls, transform) {
   }
   return freeze(mapped);
 }
+// Implements extension method ListBuilder::removeLast
+export function listBuilderRemoveLast(ls) {
+  if (ls.length) {
+    return ls.pop();
+  } else {
+    throw noResultException;
+  }
+}
 // Implements extension method ListBuilder::reverse
 export function listBuilderReverse(ls) {
   let { length } = ls;
@@ -548,11 +570,17 @@ export function listBuilderReverse(ls) {
 }
 // Implements extension method ListBuilder::set
 export function listBuilderSet(ls, i, newValue) {
-  let { length } = ls;
-  if (0 <= i && i <= length) {
+  if (0 <= i && i <= ls.length) {
     ls[i] = newValue;
   }
-  return; // of type tVoid
+}
+// Implements extension method ListBuilder::removeLast
+export function listBuilderSplice(ls, index, removeCount, newValues) {
+  // Missing count is all, but explicit undefined is 0, so give explicit length.
+  if (removeCount === undefined) {
+    removeCount = ls.length;
+  }
+  return freeze(ls.splice(index, removeCount, ...(newValues || [])));
 }
 // Implements extension method ListBuilder::toList
 export function listBuilderToList(ls) {
@@ -560,11 +588,87 @@ export function listBuilderToList(ls) {
 }
 // Implements extension method List::slice
 export function listSlice(ls, startInclusive, endExclusive) {
-  if (startInclusive < 0) { startInclusive = 0; }
-  if (endExclusive < 0) { endExclusive = 0; }
+  if (startInclusive < 0) {
+    startInclusive = 0;
+  }
+  if (endExclusive < 0) {
+    endExclusive = 0;
+  }
   return freeze(ls.slice(startInclusive, endExclusive));
 }
 
+// Map
+class FreezeMap extends Map {
+  // TODO Don't worry to freeze? Or worry more by wrapping private map?
+  // TODO Wrapping/Object.proxy presumably pays an extra cost when wrapped.
+  clear() {
+    throw new TypeError();
+  }
+  delete() {
+    throw new TypeError();
+  }
+  set(key, value) {
+    if (Object.isFrozen(this)) {
+      // Crash only after frozen because constructor calls set.
+      throw new TypeError();
+    }
+    return super.set(key, value);
+  }
+}
+export function mapConstructor(entries) {
+  return Object.freeze(new FreezeMap(entries));
+}
+// MapBuilder
+export function mapBuilderConstructor(entries) {
+  return new Map();
+}
+export function mapBuilderRemove(builder, key) {
+  const result = builder.get(key);
+  if (builder.delete(key)) {
+    return result;
+  } else {
+    throw noResultException;
+  }
+}
+export function mapBuilderSet(builder, key, value) {
+  builder.set(key, value);
+}
+export function mapBuilderToMap(builder) {
+  return Object.freeze(new FreezeMap(builder));
+}
+// Pair
+class Pair {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+  }
+  get [0]() {
+    return this.key;
+  }
+  get [1]() {
+    return this.value;
+  }
+  get length() {
+    return 2;
+  }
+}
+export function pairConstructor(key, value) {
+  return Object.freeze(new Pair(key, value));
+}
+// Mapped
+export function mappedGet(map, key) {
+  const result = map.get(key);
+  // TODO Under compiler-error-free Temper, could undefined values get set?
+  // TODO Would Map<?, Void> be impossible to feed once we get checks in place?
+  if (result === undefined) {
+    throw noResultException;
+  }
+  return result;
+}
+export function mappedToList(map) {
+  return Array.from(map, ([key, value]) => new Pair(key, value));
+}
+
 // Implements extension method Deque::constructor
 const DEQUE_NTAKEN = Symbol("Deque::nTaken");
 export function dequeConstructor() {
@@ -592,7 +696,9 @@ export function dequeRemoveFirst(deque) {
   }
   let item = deque[nTaken];
   let nShiftThreshhold = (length / 2) | 0;
-  if (nShiftThreshhold < 32) { nShiftThreshhold = 32; }
+  if (nShiftThreshhold < 32) {
+    nShiftThreshhold = 32;
+  }
   if (nTaken >= nShiftThreshhold) {
     deque.splice(0, nTaken + 1);
     deque[DEQUE_NTAKEN] = 0;
@@ -603,36 +709,24 @@ export function dequeRemoveFirst(deque) {
   return item;
 }
 
-const ZERO_N = BigInt(0);
-const ONE_N = BigInt(1);
 class DenseBitVector {
-  #bits /* : BigInt */;
-
   constructor() {
-    this.#bits = ZERO_N;
+    this.bits = [];
   }
 
   get(index) {
-    return (this.#bits & (ONE_N << BigInt(index))) !== ZERO_N;
+    return this.bits[index] == null ? false : this.bits[index];
   }
 
   set(index, newBitValue) {
-    let mask = ONE_N << BigInt(index);
-    this.#bits = newBitValue
-      ? (this.#bits | mask)
-      : (this.#bits & ~mask);
+    this.bits[index] = Boolean(newBitValue);
   }
 
   toString() {
-    return `${this.#bits}`;
-  }
-
-  valueOf() {
-    return this.#bits;
+    return `0b${this.bits.map(Number).join("")}`;
   }
-
   toJSON() {
-    return this.#bits;
+    return this.bits;
   }
 }
 
@@ -651,7 +745,7 @@ export function denseBitVectorSet(denseBitVector, index, newBitValue) {
 
 // Implements extension method Boolean::toString
 export function booleanToString(b) {
-  return b ? 'true' : 'false';
+  return b ? "true" : "false";
 }
 
 // Implements Symbol construction.
@@ -660,7 +754,7 @@ export function symbolFor(text) {
 }
 
 // Stubs out static property verification
-export function getStatic(typeGuard, symbol) {
+export function getStatic(reifiedType, symbol) {
   return undefined; // TODO(bps, #780)
 }
 
@@ -679,116 +773,197 @@ export {
 // Export runtime value type checks used for safe casting
 
 export function requireIsArray(x) {
-  if (!isArray) { throw noResultException; }
+  if (!isArray(x)) {
+    throw noResultException;
+  }
   return x;
 }
 
 export function requireInstanceOf(x, typeRequirement) {
-  if (!(x instanceof typeRequirement)) { throw noResultException; }
+  if (!(x instanceof typeRequirement)) {
+    throw noResultException;
+  }
   return x;
 }
 
 export function requireIsSafeInteger(x) {
-  if (!isSafeInteger(x)) { throw noResultException; }
+  if (!isSafeInteger(x)) {
+    throw noResultException;
+  }
   return x;
 }
 
 export function requireSame(x, y) {
-  if (x !== y) { throw noResultException; }
+  if (x !== y) {
+    throw noResultException;
+  }
   return x;
 }
 
 export function requireTypeOf(x, typeOfString) {
-  if (typeof x !== typeOfString) { throw noResultException; }
+  if (typeof x !== typeOfString) {
+    throw noResultException;
+  }
   return x;
 }
 
 // When we need a reference to builtin that normally we inline
-export function bitwiseAnd(a, b) { return a & b; }
-export function bitwiseOr(a, b) { return a | b; }
-export function booleanNegation(b) { return !b; }
-export function divDubDub(x, y) { return x / y; }
+export function bitwiseAnd(a, b) {
+  return a & b;
+}
+export function bitwiseOr(a, b) {
+  return a | b;
+}
+export function booleanNegation(b) {
+  return !b;
+}
+export function divDubDub(x, y) {
+  return x / y;
+}
 export function divIntInt(x, y) {
   const result = trunc(x / y);
-  if (!isSafeInteger(result)) { throw noResultException; }
+  if (!isSafeInteger(result)) {
+    throw noResultException;
+  }
   /* not NaN or infinite */
   return result;
 }
-export function minusDub(x) { return -x; }
-export function minusInt(x) { return -x; }
-export function minusDubDub(x, y) { return x - y; }
-export function minusIntInt(x, y) { return x - y; }
-export function plusDub(x) { return +x; }
-export function plusInt(x) { return +x; }
-export function plusDubDub(x, y) { return x + y; }
-export function plusIntInt(x, y) { return x + y; }
-export function timesDubDub(x, y) { return x * y; }
-export function timesIntInt(x, y) { return x * y; }
+export function modIntInt(x, y) {
+  const result = trunc(x % y);
+  if (!isSafeInteger(result)) {
+    throw noResultException;
+  }
+  /* not NaN or infinite */
+  return result;
+}
+export function minusDub(x) {
+  return -x;
+}
+export function minusInt(x) {
+  return -x;
+}
+export function minusDubDub(x, y) {
+  return x - y;
+}
+export function minusIntInt(x, y) {
+  return x - y;
+}
+export function plusDub(x) {
+  return +x;
+}
+export function plusInt(x) {
+  return +x;
+}
+export function plusDubDub(x, y) {
+  return x + y;
+}
+export function plusIntInt(x, y) {
+  return x + y;
+}
+export function timesDubDub(x, y) {
+  return x * y;
+}
+export function timesIntInt(x, y) {
+  return x * y;
+}
 export function strCat(...args) {
-  let s = '';
+  let s = "";
   for (let arg of args) {
     s += String(arg); // Does not throw on Symbols
   }
-  return s
+  return s;
 }
-export function listify(...args) { return freeze(args); }
-export const genericCmp =
-  (a, b) => {
-    let d = 0;
-    let ta = typeof a;
-    let tb = typeof b;
-    if (ta !== tb) {
-      throw noResultException;
+export function listify(...args) {
+  return freeze(args);
+}
+export function cmpGeneric(a, b) {
+  if (typeof a === "string" && typeof b === "string") {
+    if (Object.is(a, b)) {
+      return 0;
     }
-    if (a !== b) {
-      if (ta === 'string') { // UTF-8 order for strings
-        const aLen = a.length,
-          bLen = b.length,
-          minLen = aLen < bLen ? aLen : bLen;
-        for (let i = 0; i < minLen;) {
-          let ca = a.codePointAt(i);
-          let cb = b.codePointAt(i);
-          d = ca - cb;
-          if (d) { break; }
-          i += ca < 0x10000 ? 1 : 2;
-        }
-        if (!d) {
-          d = aLen - bLen;
-        }
-      } else {
-        d = (a < b) ? -1 : 1;
+    const aLen = a.length;
+    const bLen = b.length;
+    const minLen = aLen < bLen ? aLen : bLen;
+    for (let i = 0; i < minLen; ) {
+      const ca = a.codePointAt(i);
+      const cb = b.codePointAt(i);
+      const d = ca - cb;
+      if (d !== 0) {
+        return d;
       }
-      // TODO: handle user-defined comparison
+      i += ca < 0x10000 ? 1 : 2;
+    }
+    return aLen - bLen;
+  }
+  if (typeof a === "number" && typeof b === "number") {
+    if (Object.is(a, b)) {
+      return 0;
     }
-    if (ta === 'number' && a === 0 && b === 0) {
-      // Need to sort -0 before 0, which requires converting to signed infinities
-      return genericCmp(1/a, 1/b);
+    if (a === b) {
+      return Object.is(a, 0) - Object.is(b, 0);
     }
-    return (d > 0) - (d < 0);
-  };
-export function genericLt(a, b) { return genericCmp(a, b) < 0; }
-export function genericLe(a, b) { return genericCmp(a, b) <= 0; }
-export function genericGt(a, b) { return genericCmp(a, b) > 0; }
-export function genericGe(a, b) { return genericCmp(a, b) >= 0; }
-export function genericEq(a, b) {
-  if (a === 0 && b === 0) {
-    // This sorts out the 0.0 neq to -0.0
-    return 1/a === 1/b
-  }
-  return a === b;
-}
-export function genericNe(a, b) {
-  if (a === 0 && b === 0) {
-    // This sorts out the 0.0 neq to -0.0
-    return 1/a !== 1/b
-  }
-  return a !== b;
-}
-export function fail() { throw noResultException; }
+    return a - b;
+  }
+  if (typeof a === "boolean" && typeof b === "boolean") {
+    return a - b;
+  }
+  throw noResultException;
+};
+export function ltGeneric(a, b) {
+  if (typeof a === "number" && typeof b === "number") {
+    return a < b || (a === 0 && b === 0 && Object.is(a, 0) < Object.is(b, 0));
+  }
+  if (typeof a == "boolean" && typeof b === "boolean") {
+    return a < b;
+  }
+  return cmpGeneric(a, b) < 0;
+}
+export function leGeneric(a, b) {
+  if (typeof a === "number" && typeof b === "number") {
+    return a <= b && (a !== 0 || b !== 0 || Object.is(a, 0) <= Object.is(b, 0));
+  }
+  if (typeof a == "boolean" && typeof b === "boolean") {
+    return a <= b;
+  }
+  return cmpGeneric(a, b) <= 0;
+}
+export function gtGeneric(a, b) {
+  if (typeof a === "number" && typeof b === "number") {
+    return a > b || (a === 0 && b === 0 && Object.is(a, 0) > Object.is(b, 0));
+  }
+  if (typeof a == "boolean" && typeof b === "boolean") {
+    return a > b;
+  }
+  return cmpGeneric(a, b) > 0;
+}
+export function geGeneric(a, b) {
+  if (typeof a === "number" && typeof b === "number") {
+    return a >= b && (a !== 0 || b !== 0 || Object.is(a, 0) >= Object.is(b, 0));
+  }
+  if (typeof a == "boolean" && typeof b === "boolean") {
+    return a >= b;
+  }
+  return cmpGeneric(a, b) >= 0;
+}
+export function eqGeneric(a, b) {
+  return Object.is(a, b);
+}
+export function neGeneric(a, b) {
+  return !Object.is(a, b);
+}
+export function fail() {
+  throw noResultException;
+}
 export function print(a) {
   console.log("%s", a);
   return void 0;
 }
 export function nexter(f) {
-  return ((generator) => () => generator.next())(f());
+  return (
+    (generator) => () =>
+      generator.next()
+  )(f());
 }
+
+// We might customize this in the future, but actual global console works today.
+export const globalConsole = console;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temperlang/core",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Runtime support for JS generated by Temper",
   "main": "index.js",
   "type": "module",

package/regex.js

@@ -1,10 +1,18 @@
 import {noResultException} from "./index.js";
 
-export function compiledRegexCompiledFoundIn(_, compiled, text) {
+export function compiledRegexCompiledFound(_, compiled, text) {
   return compiled.test(text);
 }
 
 export function compiledRegexCompiledFind(_, compiled, text, regexRefs) {
+  return compiledRegexCompiledFindEx(_, compiled, text, regexRefs).groups;
+}
+
+/**
+ * @param {RegExp} compiled 
+ * @param {string} text 
+ */
+function compiledRegexCompiledFindEx(_, compiled, text, regexRefs) {
   const match = compiled.exec(text);
   if (match === null) {
     throw noResultException;
@@ -24,16 +32,16 @@ export function compiledRegexCompiledFind(_, compiled, text, regexRefs) {
   }
   const begins = codePointIndices(text, rawBegins);
   // Form the matches.
-  const Group = regexRefs.match.groups[0].constructor;
-  const resultGroups = [];
+  const Group = regexRefs.group.constructor;
+  const resultGroups = new Map();
   if (defaultFull) {
-    resultGroups.push(new Group("full", match[0], begins.full));
+    resultGroups.set("full", new Group("full", match[0], begins.full));
   }
   for (const entry of Object.entries(groups)) {
     const [name, value] = entry;
-    resultGroups.push(new Group(name, value ?? "", begins[name] ?? -1));
+    resultGroups.set(name, new Group(name, value ?? "", begins[name] ?? -1));
   }
-  return new regexRefs.match.constructor(Object.freeze(resultGroups));
+  return { groups: resultGroups, index: match.index, length: match[0].length };
 }
 
 function codePointIndices(text, unitNameIndexArray) {
@@ -55,6 +63,41 @@ function codePointIndices(text, unitNameIndexArray) {
   return codeIndices;
 }
 
+/**
+ * @param {RegExp} compiled 
+ * @param {string} text 
+ * @param {(groups: Map<string, any>) => string} format 
+ * @returns {string}
+ */
+export function compiledRegexCompiledReplace(
+  _,
+  compiled,
+  text,
+  format,
+  regexRefs
+) {
+  // Simple string replace doesn't provide all match group details if we want to
+  // make our interface consistent, so we have to do this manually here.
+  // The hope is that we can optimize a bunch out when we have compile-time
+  // contant patterns and customized match result types.
+  let match;
+  try {
+    match = compiledRegexCompiledFindEx(_, compiled, text, regexRefs);
+  } catch (e) {
+    if (e === noResultException) {
+      // Manually handle no match case for our manual replace logic.
+      return text;
+    } else {
+      // This shouldn't happen if we don't have bugs, but forward it in case.
+      throw e;
+    }
+  }
+  // Index and length in js space should save some processing.
+  const { groups, index, length } = match;
+  const content = format(groups);
+  return text.slice(0, index) + content + text.slice(index + length);
+}
+
 export function compiledRegexCompileFormatted(_, formatted) {
   return new RegExp(formatted, "du"); // d:hasIndices, u:unicode
 }