@temperlang/core 0.0.4 → 0.0.6

package/index.js

@@ -1,9 +1,9 @@
 export * from "./interface-types.js";
 export * from "./regex.js";
 
-export const noResultException = new (class NoResultException extends Error {
+export const bubbleException = new (class BubbleException extends Error {
   constructor() {
-    super("NoResult");
+    super("Bubble");
   }
 })();
 
@@ -114,7 +114,7 @@ class Utf8StringSlice extends TrickyStringSlice {
     let left = this.left;
     let right = this.right;
     if (left >= right) {
-      throw noResultException;
+      throw bubbleException;
     }
 
     let content = this.content;
@@ -131,32 +131,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 +238,39 @@ class Utf16StringSlice {
     let left = this.left;
     let right = this.right;
     if (left >= right) {
-      throw noResultException;
+      throw bubbleException;
     }
     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 +329,55 @@ class CodePointsStringSlice extends TrickyStringSlice {
 
   read() {
     if (this.left >= this.right) {
-      throw noResultException;
+      throw bubbleException;
     }
     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 +417,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;
+    throw bubbleException;
   }
 }
 
@@ -458,7 +524,7 @@ export function listBuilderAdd(ls, newItem, at) {
     ls.push(newItem);
   } else {
     if (at < 0 || at > ls.length) {
-      throw noResultException;
+      throw bubbleException;
     }
     ls.splice(at, 0, newItem);
   }
@@ -469,7 +535,7 @@ export function listBuilderAddAll(ls, newItems, at) {
     ls.push(...newItems);
   } else {
     if (at < 0 || at > ls.length) {
-      throw noResultException;
+      throw bubbleException;
     }
     ls.splice(at, 0, ...newItems);
   }
@@ -505,7 +571,7 @@ export function listGet(ls, i) {
   if (0 <= i && i < length) {
     return ls[i];
   }
-  throw noResultException;
+  throw bubbleException;
 }
 // Implements extension method List::getOr
 export function listGetOr(ls, i, fallback) {
@@ -548,12 +614,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;
+    throw bubbleException;
   }
 }
 // Implements extension method ListBuilder::reverse
@@ -627,7 +701,7 @@ export function mapBuilderRemove(builder, key) {
   if (builder.delete(key)) {
     return result;
   } else {
-    throw noResultException;
+    throw bubbleException;
   }
 }
 export function mapBuilderSet(builder, key, value) {
@@ -661,7 +735,7 @@ export function mappedGet(map, 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;
+    throw bubbleException;
   }
   return result;
 }
@@ -669,6 +743,47 @@ export function mappedToList(map) {
   return Array.from(map, ([key, value]) => new Pair(key, value));
 }
 
+// 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
 const DEQUE_NTAKEN = Symbol("Deque::nTaken");
 export function dequeConstructor() {
@@ -692,7 +807,7 @@ export function dequeRemoveFirst(deque) {
   if (length === nTaken) {
     deque[DEQUE_NTAKEN] = 0;
     deque.length = 0;
-    throw noResultException;
+    throw bubbleException;
   }
   let item = deque[nTaken];
   let nShiftThreshhold = (length / 2) | 0;
@@ -774,35 +889,35 @@ export {
 
 export function requireIsArray(x) {
   if (!isArray(x)) {
-    throw noResultException;
+    throw bubbleException;
   }
   return x;
 }
 
 export function requireInstanceOf(x, typeRequirement) {
   if (!(x instanceof typeRequirement)) {
-    throw noResultException;
+    throw bubbleException;
   }
   return x;
 }
 
 export function requireIsSafeInteger(x) {
   if (!isSafeInteger(x)) {
-    throw noResultException;
+    throw bubbleException;
   }
   return x;
 }
 
 export function requireSame(x, y) {
   if (x !== y) {
-    throw noResultException;
+    throw bubbleException;
   }
   return x;
 }
 
 export function requireTypeOf(x, typeOfString) {
   if (typeof x !== typeOfString) {
-    throw noResultException;
+    throw bubbleException;
   }
   return x;
 }
@@ -823,7 +938,7 @@ export function divDubDub(x, y) {
 export function divIntInt(x, y) {
   const result = trunc(x / y);
   if (!isSafeInteger(result)) {
-    throw noResultException;
+    throw bubbleException;
   }
   /* not NaN or infinite */
   return result;
@@ -831,7 +946,7 @@ export function divIntInt(x, y) {
 export function modIntInt(x, y) {
   const result = trunc(x % y);
   if (!isSafeInteger(result)) {
-    throw noResultException;
+    throw bubbleException;
   }
   /* not NaN or infinite */
   return result;
@@ -907,7 +1022,7 @@ export function cmpGeneric(a, b) {
   if (typeof a === "boolean" && typeof b === "boolean") {
     return a - b;
   }
-  throw noResultException;
+  throw bubbleException;
 };
 export function ltGeneric(a, b) {
   if (typeof a === "number" && typeof b === "number") {
@@ -951,8 +1066,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 bubbleException;
 }
 export function print(a) {
   console.log("%s", a);

package/package.json

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

package/regex.js

@@ -1,4 +1,4 @@
-import {noResultException} from "./index.js";
+import {bubbleException} from "./index.js";
 
 export function compiledRegexCompiledFound(_, compiled, text) {
   return compiled.test(text);
@@ -9,13 +9,13 @@ export function compiledRegexCompiledFind(_, compiled, text, regexRefs) {
 }
 
 /**
- * @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;
+    throw bubbleException;
   }
   const { groups, indices: { groups: indexGroups } } = match;
   // Find the begin indices in code points for all matched groups.
@@ -64,9 +64,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(
@@ -84,7 +84,7 @@ export function compiledRegexCompiledReplace(
   try {
     match = compiledRegexCompiledFindEx(_, compiled, text, regexRefs);
   } catch (e) {
-    if (e === noResultException) {
+    if (e === bubbleException) {
       // Manually handle no match case for our manual replace logic.
       return text;
     } else {