@temperlang/core 0.0.6 → 0.2.0

package/index.js

@@ -1,19 +1,42 @@
 export * from "./interface-types.js";
 export * from "./regex.js";
 
-export const bubbleException = new (class BubbleException extends Error {
-  constructor() {
-    super("Bubble");
-  }
-})();
-
 // 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);
+  return separator ? s.split(separator).map((s) => s) : Array.from(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. */
@@ -114,7 +137,7 @@ class Utf8StringSlice extends TrickyStringSlice {
     let left = this.left;
     let right = this.right;
     if (left >= right) {
-      throw bubbleException;
+      bubble();
     }
 
     let content = this.content;
@@ -238,7 +261,7 @@ class Utf16StringSlice {
     let left = this.left;
     let right = this.right;
     if (left >= right) {
-      throw bubbleException;
+      bubble();
     }
     return this.content.charCodeAt(left);
   }
@@ -329,7 +352,7 @@ class CodePointsStringSlice extends TrickyStringSlice {
 
   read() {
     if (this.left >= this.right) {
-      throw bubbleException;
+      bubble();
     }
     return this.content.codePointAt(this.left);
   }
@@ -435,7 +458,7 @@ export function float64ToInt(n) {
   if (Math.abs(n - i) < 1) {
     return i;
   } else {
-    throw bubbleException;
+    bubble();
   }
 }
 
@@ -454,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] || ""}`;
+    }
   }
 }
 
@@ -512,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) {
@@ -524,7 +534,7 @@ export function listBuilderAdd(ls, newItem, at) {
     ls.push(newItem);
   } else {
     if (at < 0 || at > ls.length) {
-      throw bubbleException;
+      bubble();
     }
     ls.splice(at, 0, newItem);
   }
@@ -535,7 +545,7 @@ export function listBuilderAddAll(ls, newItems, at) {
     ls.push(...newItems);
   } else {
     if (at < 0 || at > ls.length) {
-      throw bubbleException;
+      bubble();
     }
     ls.splice(at, 0, ...newItems);
   }
@@ -571,7 +581,7 @@ export function listGet(ls, i) {
   if (0 <= i && i < length) {
     return ls[i];
   }
-  throw bubbleException;
+  bubble();
 }
 // Implements extension method List::getOr
 export function listGetOr(ls, i, fallback) {
@@ -627,7 +637,7 @@ export function listBuilderRemoveLast(ls) {
   if (ls.length) {
     return ls.pop();
   } else {
-    throw bubbleException;
+    bubble();
   }
 }
 // Implements extension method ListBuilder::reverse
@@ -690,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) {
@@ -701,14 +711,23 @@ export function mapBuilderRemove(builder, key) {
   if (builder.delete(key)) {
     return result;
   } else {
-    throw bubbleException;
+    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 {
@@ -727,20 +746,47 @@ 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?
   if (result === undefined) {
-    throw bubbleException;
+    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
@@ -807,7 +853,7 @@ export function dequeRemoveFirst(deque) {
   if (length === nTaken) {
     deque[DEQUE_NTAKEN] = 0;
     deque.length = 0;
-    throw bubbleException;
+    bubble();
   }
   let item = deque[nTaken];
   let nShiftThreshhold = (length / 2) | 0;
@@ -877,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
@@ -889,35 +936,35 @@ export {
 
 export function requireIsArray(x) {
   if (!isArray(x)) {
-    throw bubbleException;
+    bubble();
   }
   return x;
 }
 
 export function requireInstanceOf(x, typeRequirement) {
   if (!(x instanceof typeRequirement)) {
-    throw bubbleException;
+    bubble();
   }
   return x;
 }
 
 export function requireIsSafeInteger(x) {
   if (!isSafeInteger(x)) {
-    throw bubbleException;
+    bubble();
   }
   return x;
 }
 
 export function requireSame(x, y) {
   if (x !== y) {
-    throw bubbleException;
+    bubble();
   }
   return x;
 }
 
 export function requireTypeOf(x, typeOfString) {
   if (typeof x !== typeOfString) {
-    throw bubbleException;
+    bubble();
   }
   return x;
 }
@@ -938,7 +985,7 @@ export function divDubDub(x, y) {
 export function divIntInt(x, y) {
   const result = trunc(x / y);
   if (!isSafeInteger(result)) {
-    throw bubbleException;
+    bubble();
   }
   /* not NaN or infinite */
   return result;
@@ -946,7 +993,7 @@ export function divIntInt(x, y) {
 export function modIntInt(x, y) {
   const result = trunc(x % y);
   if (!isSafeInteger(result)) {
-    throw bubbleException;
+    bubble();
   }
   /* not NaN or infinite */
   return result;
@@ -1017,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 bubbleException;
+  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;
@@ -1035,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;
@@ -1044,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;
@@ -1053,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;
@@ -1067,17 +1131,15 @@ export function neGeneric(a, b) {
   return !Object.is(a, b);
 }
 export function bubble() {
-  throw bubbleException;
+  throw Error();
 }
 export function print(a) {
   console.log("%s", a);
   return void 0;
 }
-export function nexter(f) {
-  return (
-    (generator) => () =>
-      generator.next()
-  )(f());
+
+export function adaptGenerator(generator) {
+  return () => generator.next();
 }
 
 // We might customize this in the future, but actual global console works today.

package/package.json

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

package/regex.js

@@ -1,11 +1,14 @@
-import {bubbleException} 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;
 }
 
 /**
@@ -15,9 +18,11 @@ export function compiledRegexCompiledFind(_, compiled, text, regexRefs) {
 function compiledRegexCompiledFindEx(_, compiled, text, regexRefs) {
   const match = compiled.exec(text);
   if (match === null) {
-    throw bubbleException;
+    return undefined;
   }
-  const { groups, indices: { groups: indexGroups } } = match;
+  const { groups: groupsMaybe, indices: { groups: indexGroupsMaybe } } = match;
+  const groups = groupsMaybe || {};
+  const indexGroups = indexGroupsMaybe || [];
   // Find the begin indices in code points for all matched groups.
   const rawBegins = [];
   const defaultFull = !("full" in groups);
@@ -80,17 +85,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 === bubbleException) {
-      // 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;