@temperlang/core 0.0.5 → 0.1.0

package/index.js

@@ -1,21 +1,44 @@
 export * from "./interface-types.js";
 export * from "./regex.js";
 
-export const noResultException = new (class NoResultException extends Error {
-  constructor() {
-    super("NoResult");
-  }
-})();
-
 // Implements extension method String::isEmpty
 export function stringIsEmpty(s) {
   return s === "";
 }
+
 // Implements extension method String::split
 export function stringSplit(s, separator) {
   return s.split(separator).map((s) => s);
 }
 
+/**
+ * Implements extension method String::toFloat64
+ * @param {string} s
+ */
+export function stringToFloat64(s) {
+  // TODO Consider JSON.parse + bonus constants instead? Faster or not?
+  if (!/^\s*-?(?:\d+(?:\.\d+)?(?:[eE][-+]?\d+)?|NaN|Infinity)\s*$/.test(s)) {
+    bubble();
+  }
+  return Number(s);
+}
+
+/**
+ * Implements extension method String::toInt
+ * @param {string} s
+ */
+export function stringToInt(s) {
+  // I'm not sure there's another simple reliable way to know if it's all used.
+  // This also checks against things like 2e0 -> 2.
+  if (!/^\s*-?\d+\s*$/.test(s)) {
+    bubble();
+  }
+  const result = parseInt(s, 10);
+  // TODO Could we use a more precise regex above to avoid this check here?
+  requireIsSafeInteger(result);
+  return result;
+}
+
 /** Specifically for utf8 and utf32, since utf16 is simpler in js. */
 class TrickyStringSlice {
   hasAtLeast(count) {
@@ -114,7 +137,7 @@ class Utf8StringSlice extends TrickyStringSlice {
     let left = this.left;
     let right = this.right;
     if (left >= right) {
-      throw noResultException;
+      bubble();
     }
 
     let content = this.content;
@@ -131,32 +154,53 @@ class Utf8StringSlice extends TrickyStringSlice {
     }
   }
 
-  advance(count) {
-    if (count <= 0) {
-      return this;
-    } else if (count === 1) {
-      let left = this.left;
-      let right = this.right;
-      if (left >= right) {
-        return this;
-      }
-      let content = this.content;
-      let cp = content.codePointAt(left >> 2);
-      let newLeft;
-      if (cp < 0x80) {
-        newLeft = left + 4;
+  /**
+   * @param {number} count
+   * @return {number}
+   */
+  _advanceLeft(count) {
+    let left = this.left;
+    let content = this.content;
+    let contentLen = content.length;
+    let idx = left >> 2;
+    let sub = left & 3;
+
+    while (count > 0 && idx < contentLen) {
+      let cp = content.codePointAt(idx);
+      let rem = nUtf8BytesInChar(cp) - sub;
+      if (rem > count) {
+        sub += count;
+        count = 0;
       } else {
-        let byteOffset = left & 3;
-        let nBytes = nUtf8BytesInChar(cp);
-        newLeft =
-          byteOffset + 1 < nBytes
-            ? left + 1
-            : (left & ~3) + ((nBytes + 4) & ~3);
+        count -= rem;
+        sub = 0;
+        idx += cp > 0x10000 ? 2 : 1;
       }
-      return new Utf8StringSlice(content, newLeft, right);
-    } else {
-      throw new Error("TODO");
     }
+
+    return count ? this.right : Math.min(idx << 2 | sub, this.right);
+  }
+
+  /**
+   * @param {number} count
+   * @return {Utf8StringSlice}
+   */
+  advance(count) {
+    let newLeft = this._advanceLeft(count);
+    return (this.left === newLeft)
+      ? this
+      : new Utf8StringSlice(this.content, newLeft, this.right);
+  }
+
+  /**
+   * @param {number} count
+   * @return {Utf8StringSlice}
+   */
+  limit(count) {
+    let newRight = this._advanceLeft(count);
+    return (this.right === newRight)
+      ? this
+      : new Utf8StringSlice(this.content, this.left, newRight);
   }
 
   [Symbol.iterator]() {
@@ -217,26 +261,39 @@ class Utf16StringSlice {
     let left = this.left;
     let right = this.right;
     if (left >= right) {
-      throw noResultException;
+      bubble();
     }
     return this.content.charCodeAt(left);
   }
 
+  /**
+   * @param {number} count
+   * @return {number}
+   */
+  _advanceLeft(count) {
+    return Math.min(this.left + count, this.right);
+  }
+
+  /**
+   * @param {number} count
+   * @return {Utf16StringSlice}
+   */
   advance(count) {
-    if (count <= 0) {
-      return this;
-    } else {
-      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);
-    }
+    let newLeft = this._advanceLeft(count);
+    return this.left === newLeft
+      ? this
+      : new Utf16StringSlice(this.content, newLeft, this.right);
+  }
+
+  /**
+   * @param {number} count
+   * @return {Utf16StringSlice}
+   */
+  limit(count) {
+    let newRight = this._advanceLeft(count);
+    return this.right === newRight
+      ? this
+      : new Utf16StringSlice(this.content, this.left, newRight);
   }
 
   [Symbol.iterator]() {
@@ -295,35 +352,55 @@ class CodePointsStringSlice extends TrickyStringSlice {
 
   read() {
     if (this.left >= this.right) {
-      throw noResultException;
+      bubble();
     }
     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;
-      if (left >= right) {
-        return this;
-      }
-      let newLeft = left;
-      for (let i = count; i && newLeft < right; --i) {
-        let cp = content.codePointAt(newLeft);
-        if (cp > 0xffff) {
-          newLeft += 2;
-        } else {
-          newLeft += 1;
-        }
-      }
-      if (newLeft >= right) {
-        newLeft = right;
+  /**
+   * @param {number} count
+   * @return {number}
+   */
+  _advanceLeft(count) {
+    let left = this.left;
+    let right = this.right;
+    let content = this.content;
+    if (count <= 0) { return left }
+    let newLeft = left;
+    for (let i = count; i && newLeft < right; --i) {
+      let cp = content.codePointAt(newLeft);
+      if (cp > 0xffff) {
+        newLeft += 2;
+      } else {
+        newLeft += 1;
       }
-      return new CodePointsStringSlice(this.content, newLeft, right);
     }
+    if (newLeft >= right) {
+      newLeft = right;
+    }
+    return newLeft;
+  }
+
+  /**
+   * @param {number} count
+   * @return {CodePointsStringSlice}
+   */
+  advance(count) {
+    let newLeft = this._advanceLeft(count);
+    return (newLeft === this.left)
+      ? this
+      : new CodePointsStringSlice(this.content, newLeft, this.right);
+  }
+
+  /**
+   * @param {number} count
+   * @return {CodePointsStringSlice}
+   */
+  limit(count) {
+    let newRight = this._advanceLeft(count);
+    return (newRight === this.right)
+      ? this
+      : new CodePointsStringSlice(this.content, this.left, newRight);
   }
 
   [Symbol.iterator]() {
@@ -363,13 +440,25 @@ export function intToString(i, radix) {
   return i.toString(radix);
 }
 
+// Implements extension method Float64::near
+export function float64Near(x, y, relTol, absTol) {
+  if (relTol === undefined) {
+    relTol = 1e-9;
+  }
+  if (absTol === undefined) {
+    absTol = 0;
+  }
+  const margin = Math.max(Math.max(Math.abs(x), Math.abs(y)) * relTol, absTol);
+  return Math.abs(x - y) < margin;
+}
+
 // Implements extension method Float64::toInt
 export function float64ToInt(n) {
   const i = float64ToIntUnsafe(n);
   if (Math.abs(n - i) < 1) {
     return i;
   } else {
-    throw noResultException;
+    bubble();
   }
 }
 
@@ -388,27 +477,18 @@ export function float64ToIntUnsafe(n) {
 export function float64ToString(n) {
   // TODO(mikesamuel, issue#579): need functional test to nail down
   // double formatting threshholds.
-  switch (n) {
-    case 0:
-      if (Object.is(n, -0)) {
-        return "-0.0";
-      } else {
-        return "0.0";
-      }
-    case Infinity:
-      return "∞";
-    case Number.NEGATIVE_INFINITY:
-      return "-∞";
-    default:
-      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] || ""}`;
-      }
+  if (n == 0) {
+    return Object.is(n, -0) ? "-0.0" : "0.0";
+  } else {
+    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] || ""}`;
+    }
   }
 }
 
@@ -446,10 +526,6 @@ const byteInfos = [
   { andMask: 0b0011_1111, orMask: 0b1000_0000, shift: 0 },
 ];
 
-function freeze(items) {
-  return Object.freeze(items);
-}
-
 // Implements extension method ListBuilder::add
 export function listBuilderAdd(ls, newItem, at) {
   if (at === undefined) {
@@ -458,7 +534,7 @@ export function listBuilderAdd(ls, newItem, at) {
     ls.push(newItem);
   } else {
     if (at < 0 || at > ls.length) {
-      throw noResultException;
+      bubble();
     }
     ls.splice(at, 0, newItem);
   }
@@ -469,7 +545,7 @@ export function listBuilderAddAll(ls, newItems, at) {
     ls.push(...newItems);
   } else {
     if (at < 0 || at > ls.length) {
-      throw noResultException;
+      bubble();
     }
     ls.splice(at, 0, ...newItems);
   }
@@ -505,7 +581,7 @@ export function listGet(ls, i) {
   if (0 <= i && i < length) {
     return ls[i];
   }
-  throw noResultException;
+  bubble();
 }
 // Implements extension method List::getOr
 export function listGetOr(ls, i, fallback) {
@@ -548,12 +624,20 @@ export function listMap(ls, transform) {
   }
   return freeze(mapped);
 }
+// Implements extension method Listed::toList
+export function listedToList(ls) {
+  if (Object.isFrozen(ls)) {
+    return ls;
+  } else {
+    return listBuilderToList(ls);
+  }
+}
 // Implements extension method ListBuilder::removeLast
 export function listBuilderRemoveLast(ls) {
   if (ls.length) {
     return ls.pop();
   } else {
-    throw noResultException;
+    bubble();
   }
 }
 // Implements extension method ListBuilder::reverse
@@ -616,7 +700,7 @@ class FreezeMap extends Map {
   }
 }
 export function mapConstructor(entries) {
-  return Object.freeze(new FreezeMap(entries));
+  return freeze(new FreezeMap(entries));
 }
 // MapBuilder
 export function mapBuilderConstructor(entries) {
@@ -627,14 +711,23 @@ export function mapBuilderRemove(builder, key) {
   if (builder.delete(key)) {
     return result;
   } else {
-    throw noResultException;
+    bubble();
   }
 }
 export function mapBuilderSet(builder, key, value) {
   builder.set(key, value);
 }
-export function mapBuilderToMap(builder) {
-  return Object.freeze(new FreezeMap(builder));
+export function mappedToMap(mapped) {
+  if (mapped instanceof FreezeMap) {
+    return mapped;
+  }
+  return freeze(new FreezeMap(mapped));
+}
+export function mapBuilderToMap(mapped) {
+  return freeze(new FreezeMap(mapped));
+}
+export function mappedToMapBuilder(mapped) {
+  return new Map(mapped);
 }
 // Pair
 class Pair {
@@ -653,20 +746,88 @@ class Pair {
   }
 }
 export function pairConstructor(key, value) {
-  return Object.freeze(new Pair(key, value));
+  return freeze(new Pair(key, value));
 }
 // Mapped
+export function mappedLength(map) {
+  return map.size;
+}
 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?
+// TODO Would Map<?, Void> be impossible to feed once we get checks in place?
   if (result === undefined) {
-    throw noResultException;
+    bubble();
   }
   return result;
 }
+export function mappedGetOr(map, key, fallback) {
+  return map.get(key) ?? fallback;
+}
+export function mappedHas(map, key) {
+  return map.has(key);
+}
+export function mappedKeys(map) {
+  return freeze(Array.prototype.slice.call(map.keys()));
+}
+export function mappedValues(map) {
+  return freeze(Array.prototype.slice.call(map.values()));
+}
 export function mappedToList(map) {
-  return Array.from(map, ([key, value]) => new Pair(key, value));
+  return freeze(Array.from(map, ([key, value]) => new Pair(key, value)));
+}
+export function mappedToListWith(map, func) {
+  return freeze(Array.from(map, ([key, value]) => func(key, value)));
+}
+export function mappedToListBuilder(map) {
+  return freeze(Array.from(map, ([key, value]) => new Pair(key, value)));
+}
+export function mappedToListBuilderWith(map, func) {
+  return freeze(Array.from(map, ([key, value]) => func(key, value)));
+}
+export function mappedForEach(map, func) {
+  map.forEach((v, k) => func(k, v));
+}
+
+// Implements Date::constructor
+export function dateConstructor(year, month, day) {
+  let d = new Date(0);
+  // If we were to pass year into `new Date`, then it would
+  // have 1900 added when in the range [0, 99].
+  // developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date#year
+  d.setUTCFullYear(year);
+  d.setUTCMonth(month - 1 /* JS months are zero indexed */);
+  d.setUTCDate(day);  // UTCDay is day of the week
+  return d;
+}
+
+// Implements Date::today
+/**
+ * @returns {Date}
+ */
+export function dateToday() {
+  let d = new Date(Date.now());
+  // Get rid of the time component.
+  d.setTime(
+    Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate())
+  );
+  return d;
+}
+
+// Implements Date::yearsBetween
+/**
+ * @param {Date} start
+ * @param {Date} end
+ *
+ * @returns {number}
+ */
+export function dateYearsBetween(start, end) {
+  let yearDelta = end.getUTCFullYear() - start.getUTCFullYear();
+  let monthDelta = end.getUTCMonth() - start.getUTCMonth();
+  return yearDelta -
+      // If the end month/day is before the start's then we
+      // don't have a full year.
+      (monthDelta < 0 || monthDelta == 0 && end.getUTCDate() < start.getUTCDate());
 }
 
 // Implements extension method Deque::constructor
@@ -692,7 +853,7 @@ export function dequeRemoveFirst(deque) {
   if (length === nTaken) {
     deque[DEQUE_NTAKEN] = 0;
     deque.length = 0;
-    throw noResultException;
+    bubble();
   }
   let item = deque[nTaken];
   let nShiftThreshhold = (length / 2) | 0;
@@ -762,6 +923,7 @@ const String = "".constructor;
 const { isArray } = Array;
 const { isSafeInteger } = Number;
 const { trunc } = Math;
+const { freeze } = Object;
 
 export {
   // Export reliable paths to JS builtins, so they can import them
@@ -774,35 +936,35 @@ export {
 
 export function requireIsArray(x) {
   if (!isArray(x)) {
-    throw noResultException;
+    bubble();
   }
   return x;
 }
 
 export function requireInstanceOf(x, typeRequirement) {
   if (!(x instanceof typeRequirement)) {
-    throw noResultException;
+    bubble();
   }
   return x;
 }
 
 export function requireIsSafeInteger(x) {
   if (!isSafeInteger(x)) {
-    throw noResultException;
+    bubble();
   }
   return x;
 }
 
 export function requireSame(x, y) {
   if (x !== y) {
-    throw noResultException;
+    bubble();
   }
   return x;
 }
 
 export function requireTypeOf(x, typeOfString) {
   if (typeof x !== typeOfString) {
-    throw noResultException;
+    bubble();
   }
   return x;
 }
@@ -823,7 +985,7 @@ export function divDubDub(x, y) {
 export function divIntInt(x, y) {
   const result = trunc(x / y);
   if (!isSafeInteger(result)) {
-    throw noResultException;
+    bubble();
   }
   /* not NaN or infinite */
   return result;
@@ -831,7 +993,7 @@ export function divIntInt(x, y) {
 export function modIntInt(x, y) {
   const result = trunc(x % y);
   if (!isSafeInteger(result)) {
-    throw noResultException;
+    bubble();
   }
   /* not NaN or infinite */
   return result;
@@ -902,16 +1064,23 @@ export function cmpGeneric(a, b) {
     if (a === b) {
       return Object.is(a, 0) - Object.is(b, 0);
     }
+    if (isNaN(a) || isNaN(b)) {
+      return isNaN(a) - isNaN(b);
+    }
     return a - b;
   }
   if (typeof a === "boolean" && typeof b === "boolean") {
     return a - b;
   }
-  throw noResultException;
+  bubble();
 };
 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));
+    return (
+      (isNaN(b) && !isNaN(a)) ||
+      a < b ||
+      (a === 0 && b === 0 && Object.is(a, 0) < Object.is(b, 0))
+    );
   }
   if (typeof a == "boolean" && typeof b === "boolean") {
     return a < b;
@@ -920,7 +1089,10 @@ export function ltGeneric(a, b) {
 }
 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));
+    return (
+      isNaN(b) ||
+      (a <= b && (a !== 0 || b !== 0 || Object.is(a, 0) <= Object.is(b, 0)))
+    );
   }
   if (typeof a == "boolean" && typeof b === "boolean") {
     return a <= b;
@@ -929,7 +1101,11 @@ export function leGeneric(a, b) {
 }
 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));
+    return (
+      (isNaN(a) && !isNaN(b)) ||
+      a > b ||
+      (a === 0 && b === 0 && Object.is(a, 0) > Object.is(b, 0))
+    );
   }
   if (typeof a == "boolean" && typeof b === "boolean") {
     return a > b;
@@ -938,7 +1114,10 @@ export function gtGeneric(a, b) {
 }
 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));
+    return (
+      isNaN(a) ||
+      (a >= b && (a !== 0 || b !== 0 || Object.is(a, 0) >= Object.is(b, 0)))
+    );
   }
   if (typeof a == "boolean" && typeof b === "boolean") {
     return a >= b;
@@ -951,8 +1130,8 @@ export function eqGeneric(a, b) {
 export function neGeneric(a, b) {
   return !Object.is(a, b);
 }
-export function fail() {
-  throw noResultException;
+export function bubble() {
+  throw Error();
 }
 export function print(a) {
   console.log("%s", a);

package/package.json

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

package/regex.js

@@ -1,21 +1,24 @@
-import {noResultException} from "./index.js";
-
 export function compiledRegexCompiledFound(_, compiled, text) {
   return compiled.test(text);
 }
 
 export function compiledRegexCompiledFind(_, compiled, text, regexRefs) {
-  return compiledRegexCompiledFindEx(_, compiled, text, regexRefs).groups;
+  const match = compiledRegexCompiledFindEx(_, compiled, text, regexRefs);
+  if (match === undefined) {
+    // We could just fail on `undefined.groups`, but that seems accidental.
+    throw Error();
+  }
+  return match.groups;
 }
 
 /**
- * @param {RegExp} compiled 
- * @param {string} text 
+ * @param {RegExp} compiled
+ * @param {string} text
  */
 function compiledRegexCompiledFindEx(_, compiled, text, regexRefs) {
   const match = compiled.exec(text);
   if (match === null) {
-    throw noResultException;
+    return undefined;
   }
   const { groups, indices: { groups: indexGroups } } = match;
   // Find the begin indices in code points for all matched groups.
@@ -64,9 +67,9 @@ function codePointIndices(text, unitNameIndexArray) {
 }
 
 /**
- * @param {RegExp} compiled 
- * @param {string} text 
- * @param {(groups: Map<string, any>) => string} format 
+ * @param {RegExp} compiled
+ * @param {string} text
+ * @param {(groups: Map<string, any>) => string} format
  * @returns {string}
  */
 export function compiledRegexCompiledReplace(
@@ -80,17 +83,10 @@ export function compiledRegexCompiledReplace(
   // 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;
-    }
+  let match = compiledRegexCompiledFindEx(_, compiled, text, regexRefs);
+  if (match === undefined) {
+    // Manually handle no match case for our manual replace logic.
+    return text;
   }
   // Index and length in js space should save some processing.
   const { groups, index, length } = match;