@temperlang/core 0.2.1 → 0.3.0

package/index.js

@@ -39,7 +39,16 @@ export function stringToInt(s) {
   return result;
 }
 
-/** Specifically for utf8 and utf32, since utf16 is simpler in js. */
+/**
+ * @typedef StringSlice
+ */
+let StringSlice;
+
+/**
+ * Specifically for utf8 and utf32, since utf16 is simpler in js.
+ *
+ * @implements StringSlice
+ */
 class TrickyStringSlice {
   hasAtLeast(count) {
     // Repeated calls to hasAtLeast are potentially expensive.
@@ -203,6 +212,40 @@ class Utf8StringSlice extends TrickyStringSlice {
       : new Utf8StringSlice(this.content, this.left, newRight);
   }
 
+  /**
+   * @param {StringSlice} slice
+   * @return {Utf8StringSlice}
+   */
+  intersect(slice) {
+    let { content, left, right } = this;
+    let { left: otherLeft, right: otherRight } = slice;
+
+    // Derivation of this in StringSliceHelpers
+    let newLeft, newRight;
+    if (otherLeft >= right) {
+      newLeft = newRight = right;
+    } else if (otherRight <= left) {
+      newLeft = newLeft = left;
+    } else {
+      newLeft = Math.max(left, otherLeft);
+      newRight = Math.min(right, otherRight);
+    }
+    return newLeft === left && newRight === right
+      ? this : new Utf8StringSlice(content, newLeft, newRight);
+  }
+
+  /**
+   * @param {StringSlice} slice
+   * @returns {Utf8StringSlice}
+   */
+  excludeAfter(slice) {
+    let { content, left, right } = this;
+    let { left: otherLeft } = slice;
+    let newRight = Math.max(left, Math.min(right, otherLeft));
+    return right === newRight
+      ? this : new Utf8StringSlice(content, left, newRight);
+  }
+
   [Symbol.iterator]() {
     function* bytes(content, left, limit) {
       let i = left;
@@ -230,6 +273,9 @@ class Utf8StringSlice extends TrickyStringSlice {
   }
 }
 
+/**
+ * @implements StringSlice
+ */
 class Utf16StringSlice {
   constructor(content, left = 0, right = content.length) {
     this.content = content;
@@ -296,6 +342,40 @@ class Utf16StringSlice {
       : new Utf16StringSlice(this.content, this.left, newRight);
   }
 
+  /**
+   * @param {StringSlice} slice
+   * @return {Utf16StringSlice}
+   */
+  intersect(slice) {
+    let { content, left, right } = this;
+    let { left: otherLeft, right: otherRight } = slice;
+
+    // Derivation of this in StringSliceHelpers
+    let newLeft, newRight;
+    if (otherLeft >= right) {
+      newLeft = newRight = right;
+    } else if (otherRight <= left) {
+      newLeft = newLeft = left;
+    } else {
+      newLeft = Math.max(left, otherLeft);
+      newRight = Math.min(right, otherRight);
+    }
+    return newLeft === left && newRight === right
+      ? this : new Utf16StringSlice(content, newLeft, newRight);
+  }
+
+  /**
+   * @param {StringSlice} slice
+   * @returns {Utf16StringSlice}
+   */
+  excludeAfter(slice) {
+    let { content, left, right } = this;
+    let { left: otherLeft } = slice;
+    let newRight = Math.max(left, Math.min(right, otherLeft));
+    return right === newRight
+    ? this : new Utf16StringSlice(content, left, newRight);
+  }
+
   [Symbol.iterator]() {
     function* chars(content, left, limit) {
       let i = left;
@@ -312,7 +392,7 @@ class Utf16StringSlice {
   }
 }
 
-class CodePointsStringSlice extends TrickyStringSlice {
+class CodePointStringSlice extends TrickyStringSlice {
   constructor(content, left = 0, right = content.length) {
     super();
     this.content = content;
@@ -383,24 +463,57 @@ class CodePointsStringSlice extends TrickyStringSlice {
 
   /**
    * @param {number} count
-   * @return {CodePointsStringSlice}
+   * @return {CodePointStringSlice}
    */
   advance(count) {
     let newLeft = this._advanceLeft(count);
     return (newLeft === this.left)
       ? this
-      : new CodePointsStringSlice(this.content, newLeft, this.right);
+      : new CodePointStringSlice(this.content, newLeft, this.right);
   }
 
   /**
    * @param {number} count
-   * @return {CodePointsStringSlice}
+   * @return {CodePointStringSlice}
    */
   limit(count) {
     let newRight = this._advanceLeft(count);
     return (newRight === this.right)
       ? this
-      : new CodePointsStringSlice(this.content, this.left, newRight);
+      : new CodePointStringSlice(this.content, this.left, newRight);
+  }
+
+  /**
+   * @param {StringSlice} slice
+   * @return {CodePointStringSlice}
+   */
+  intersect(slice) {
+    let { content, left, right } = this;
+    let { left: otherLeft, right: otherRight } = slice;
+
+    // Derivation of this in StringSliceHelpers
+    let newLeft, newRight;
+    if (otherLeft >= right) {
+      newLeft = newRight = right;
+    } else if (otherRight <= left) {
+      newLeft = newLeft = left;
+    } else {
+      newLeft = Math.max(left, otherLeft);
+      newRight = Math.min(right, otherRight);
+    }
+    return newLeft === left && newRight === right
+      ? this : new CodePointStringSlice(content, newLeft, newRight);
+  }
+
+  /**
+   * @param {StringSlice} slice
+   * @returns {CodePointStringSlice}
+   */
+  excludeAfter(slice) {
+    let { content, left, right } = this;
+    let { left: otherLeft } = slice;
+    let newRight = Math.max(left, Math.min(right, otherLeft));
+    return right === newRight ? this : new CodePointStringSlice(content, left, newRight);
   }
 
   [Symbol.iterator]() {
@@ -432,7 +545,7 @@ export function stringUtf16(string) {
 
 // Implements extension method String::codePoints
 export function stringCodePoints(string) {
-  return new CodePointsStringSlice(string);
+  return new CodePointStringSlice(string);
 }
 
 // Implements extension method Int::toString
@@ -550,8 +663,8 @@ export function listBuilderAddAll(ls, newItems, at) {
     ls.splice(at, 0, ...newItems);
   }
 }
-// Implements extension method List::filter
-export function listFilter(ls, predicate) {
+// Implements extension method Listed::filter
+export function listedFilter(ls, predicate) {
   let filtered = null;
   let nFiltered = 0; // Just past index of last element of ls filtered onto filtered
   let { length } = ls;
@@ -575,16 +688,16 @@ export function listFilter(ls, predicate) {
   }
   return freeze(fullyFiltered);
 }
-// Implements extension method List::get
-export function listGet(ls, i) {
+// Implements extension method Listed::get
+export function listedGet(ls, i) {
   let { length } = ls;
   if (0 <= i && i < length) {
     return ls[i];
   }
   bubble();
 }
-// Implements extension method List::getOr
-export function listGetOr(ls, i, fallback) {
+// Implements extension method Listed::getOr
+export function listedGetOr(ls, i, fallback) {
   let { length } = ls;
   return 0 <= i && i < length ? ls[i] : fallback;
 }
@@ -592,8 +705,8 @@ export function listGetOr(ls, i, fallback) {
 export function listIsEmpty(ls) {
   return !ls.length;
 }
-// Implements extension method List::join
-export function listJoin(ls, separator, elementStringifier) {
+// Implements extension method Listed::join
+export function listedJoin(ls, separator, elementStringifier) {
   let joined = "";
   let { length } = ls;
   for (let i = 0; i < length; ++i) {
@@ -606,16 +719,12 @@ export function listJoin(ls, separator, elementStringifier) {
   }
   return joined;
 }
-// Implements extension method List::length
-export function listLength(ls) {
-  return ls.length;
-}
-// Implements extension method List::mapDropping
-export function listMapDropping() {
+// Implements extension method Listed::mapDropping
+export function listedMapDropping() {
   throw new Error("TODO List::mapDropping");
 }
-// Implements extension method List::map
-export function listMap(ls, transform) {
+// Implements extension method Listed::map
+export function listedMap(ls, transform) {
   let mapped = [];
   let { length } = ls;
   for (let i = 0; i < length; ++i) {
@@ -624,6 +733,10 @@ export function listMap(ls, transform) {
   }
   return freeze(mapped);
 }
+// Implements extension method Listed::reduceFrom
+export function listedReduceFrom(ls, initial, accumulate) {
+  return ls.reduce(accumulate, initial);
+}
 // Implements extension method Listed::toList
 export function listedToList(ls) {
   if (Object.isFrozen(ls)) {
@@ -670,8 +783,8 @@ export function listBuilderSplice(ls, index, removeCount, newValues) {
 export function listBuilderToList(ls) {
   return freeze(ls.slice());
 }
-// Implements extension method List::slice
-export function listSlice(ls, startInclusive, endExclusive) {
+// Implements extension method Listed::slice
+export function listedSlice(ls, startInclusive, endExclusive) {
   if (startInclusive < 0) {
     startInclusive = 0;
   }
@@ -1138,9 +1251,5 @@ export function print(a) {
   return void 0;
 }
 
-export function adaptGenerator(generator) {
-  return () => generator.next();
-}
-
 // 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.2.1",
+  "version": "0.3.0",
   "description": "Runtime support for JS generated by Temper",
   "main": "index.js",
   "type": "module",

package/regex.js

@@ -1,9 +1,9 @@
-export function compiledRegexCompiledFound(_, compiled, text) {
+export function regexCompiledFound(_, compiled, text) {
   return compiled.test(text);
 }
 
-export function compiledRegexCompiledFind(_, compiled, text, regexRefs) {
-  const match = compiledRegexCompiledFindEx(_, compiled, text, regexRefs);
+export function regexCompiledFind(_, compiled, text, regexRefs) {
+  const match = regexCompiledFindEx(_, compiled, text, regexRefs);
   if (match === undefined) {
     // We could just fail on `undefined.groups`, but that seems accidental.
     throw Error();
@@ -15,7 +15,7 @@ export function compiledRegexCompiledFind(_, compiled, text, regexRefs) {
  * @param {RegExp} compiled
  * @param {string} text
  */
-function compiledRegexCompiledFindEx(_, compiled, text, regexRefs) {
+function regexCompiledFindEx(_, compiled, text, regexRefs) {
   const match = compiled.exec(text);
   if (match === null) {
     return undefined;
@@ -74,7 +74,7 @@ function codePointIndices(text, unitNameIndexArray) {
  * @param {(groups: Map<string, any>) => string} format
  * @returns {string}
  */
-export function compiledRegexCompiledReplace(
+export function regexCompiledReplace(
   _,
   compiled,
   text,
@@ -85,7 +85,7 @@ 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 = compiledRegexCompiledFindEx(_, compiled, text, regexRefs);
+  let match = regexCompiledFindEx(_, compiled, text, regexRefs);
   if (match === undefined) {
     // Manually handle no match case for our manual replace logic.
     return text;
@@ -96,7 +96,7 @@ export function compiledRegexCompiledReplace(
   return text.slice(0, index) + content + text.slice(index + length);
 }
 
-export function compiledRegexCompileFormatted(_, formatted) {
+export function regexCompileFormatted(_, formatted) {
   return new RegExp(formatted, "du"); // d:hasIndices, u:unicode
 }