@temperlang/core 0.2.1 → 0.4.0

package/interface.js

@@ -0,0 +1,56 @@
+
+/**
+ * A temper Super-Type.
+ *
+ * Returns a `Union`.
+ * Temper types always extend a Union made by this function.
+ * Only takes temper types as inputs.
+ *
+ * Examples:
+ *
+ * Basic usage with multiple inheritance.
+ * ```js
+ * class Plant extends type() {}
+ * class Potato extends type(Plant) {}
+ * class Snack extends type() {}
+ * class Fry extends type(Potato, Snack) {}
+ * ```
+ *
+ * The following will not work because Basic does not extend `type()`.
+ * ```
+ * class Basic {}
+ * class Sub extends type(Basic) {}
+ * ```
+ *
+ * The following will work.
+ * ```
+ * class Pet extends type() {}
+ * class Dog extends Pet {}
+ * ```
+ *
+ * type()
+ * @param {typeof Union} superTypes
+ * @return {Union}
+ */
+export const type = (...superTypes) => {
+  const key = Symbol();
+
+  class Union {
+    static [Symbol.hasInstance] = (instance) => {
+      return key in instance;
+    };
+  }
+
+  Union.prototype[key] = null;
+
+  for (const superType of superTypes.reverse()) {
+    let proto = Object.getPrototypeOf(superType.prototype);
+    for (const sym of Object.getOwnPropertySymbols(proto)) {
+      Union.prototype[sym] = null;
+    }
+    Object.defineProperties(Union.prototype, Object.getOwnPropertyDescriptors(proto));
+    Object.defineProperties(Union.prototype, Object.getOwnPropertyDescriptors(superType.prototype));
+  }
+
+  return Union;
+};

package/listed.js

@@ -0,0 +1,289 @@
+
+// Implements extension method Listed::mapDropping
+import {bubble} from "./core.js";
+
+export const listedMapDropping = () => {
+  throw new Error("TODO List::mapDropping");
+}
+
+/**
+ * Implements extension method Listed::map
+ * @template T
+ * @template R
+ * @param {T[]} ls
+ * @param {(prev: T) => R} transform
+ * @returns {Readonly<R[]>}
+ */
+export const listedMap = (ls, transform) => {
+  let mapped = [];
+  let { length } = ls;
+  for (let i = 0; i < length; ++i) {
+    mapped[i] = transform(ls[i]);
+  }
+  return Object.freeze(mapped);
+}
+
+/**
+ * Implements extension method Listed::reduceFrom
+ * @template T, R
+ * @param {T[]} ls
+ * @param {R} initial
+ * @param {(prev: T, cur: R) => R}accumulate
+ * @returns {R}
+ */
+export const listedReduceFrom = (ls, initial, accumulate) => {
+  return ls.reduce(accumulate, initial);
+}
+
+/**
+ * Implements extension method Listed::sort
+ * @template T
+ * @param {T[]} ls
+ * @param {(lhs: T, rhs: T) => number} compare
+ */
+export const listedSorted = (ls, compare) => {
+  return Object.freeze(ls.slice().sort(compare));
+}
+
+/**
+ * Implements extension method Listed::toList
+ * @template T
+ * @param {T[] | Readonly<T[]>} ls
+ * @returns {Readonly<T[]>}
+ */
+export const listedToList = (ls) => {
+  if (Object.isFrozen(ls)) {
+    return ls;
+  } else {
+    return listBuilderToList(ls);
+  }
+}
+
+
+/**
+ * Implements extension method ListBuilder::add
+ * @template T
+ * @param {T[]} ls
+ * @param {T} newItem
+ * @param {number | null} [at]
+ */
+export const listBuilderAdd = (ls, newItem, at) => {
+  if (at == null) {
+    // Technically, we could also use splice instead of push for this case.
+    // Which is better might depend on minifiers and/or execution speed.
+    ls.push(newItem);
+  } else {
+    if (at < 0 || at > ls.length) {
+      bubble();
+    }
+    ls.splice(at, 0, newItem);
+  }
+}
+
+/**
+ * Implements extension method ListBuilder::addAll
+ * @template T
+ * @param {T[]} ls
+ * @param {T[]} newItems
+ * @param {number | null} [at]
+ */
+export const listBuilderAddAll = (ls, newItems, at) => {
+  if (at == null) {
+    ls.push(...newItems);
+  } else {
+    if (at < 0 || at > ls.length) {
+      bubble();
+    }
+    ls.splice(at, 0, ...newItems);
+  }
+}
+
+/**
+ * Implements extension method Listed::filter
+ * @template T
+ * @param {T[]} ls
+ * @param {(T) => boolean} predicate
+ * @returns {Readonly<T[]>}
+ */
+export const listedFilter = (ls, predicate) => {
+  let filtered = null;
+  let nFiltered = 0; // Just past index of last element of ls filtered onto filtered
+  let { length } = ls;
+  for (let i = 0; i < length; ++i) {
+    let element = ls[i];
+    let ok = predicate(element);
+    if (!ok) {
+      if (!filtered) {
+        filtered = [];
+      }
+      filtered.push(...ls.slice(nFiltered, i));
+      nFiltered = i + 1;
+    }
+  }
+  let fullyFiltered;
+  if (filtered) {
+    filtered.push(...ls.slice(nFiltered, length));
+    fullyFiltered = filtered;
+  } else {
+    fullyFiltered = ls;
+  }
+  return Object.freeze(fullyFiltered);
+}
+
+/**
+ * Implements extension method Listed::get
+ * @template T
+ * @param {T[]} ls
+ * @param {number} i
+ * @returns {T}
+ */
+export const listedGet = (ls, i) => {
+  let { length } = ls;
+  if (0 <= i && i < length) {
+    return ls[i];
+  }
+  bubble();
+}
+
+/**
+ * Implements extension method Listed::getOr
+ * @template T
+ * @param {T[]} ls
+ * @param {number} i
+ * @param {T} fallback
+ * @returns {T}
+ */
+export const listedGetOr = (ls, i, fallback) => {
+  let { length } = ls;
+  return 0 <= i && i < length ? ls[i] : fallback;
+}
+
+/**
+ * Implements extension method List::isEmpty
+ * @template T
+ * @param {T[]} ls
+ * @returns {boolean}
+ */
+export const listIsEmpty = (ls) => {
+  return !ls.length;
+}
+
+/**
+ * Implements extension method Listed::join
+ * @template T
+ * @param {T[]} ls
+ * @param {string} separator
+ * @param {(T) => string} elementStringifier
+ * @returns {string}
+ */
+export const listedJoin = (ls, separator, elementStringifier) => {
+  let joined = "";
+  let { length } = ls;
+  for (let i = 0; i < length; ++i) {
+    if (i) {
+      joined += separator;
+    }
+    let element = ls[i];
+    let stringifiedElement = elementStringifier(element);
+    joined += stringifiedElement;
+  }
+  return joined;
+}
+
+/**
+ * @template T
+ * @param {T[]} ls
+ */
+// Implements extension method ListBuilder::clear
+export const listBuilderClear = (ls) => {
+  ls.length = 0;
+}
+
+/**
+ * Implements extension method ListBuilder::removeLast
+ * @template T
+ * @param {T[]} ls
+ * @returns {T}
+ */
+export const listBuilderRemoveLast = (ls) => {
+  if (ls.length) {
+    return ls.pop();
+  } else {
+    bubble();
+  }
+}
+
+/**
+ * Implements extension method ListBuilder::reverse
+ * @template T
+ * @param {T[]} ls
+ */
+export const listBuilderReverse = (ls) => {
+  let { length } = ls;
+  let lastIndex = length - 1;
+  let mid = length >> 1;
+  for (let i = 0; i < mid; ++i) {
+    let j = lastIndex - i;
+    let a = ls[i];
+    ls[i] = ls[j];
+    ls[j] = a;
+  }
+}
+
+/**
+ * Implements extension method ListBuilder::set
+ * @template T
+ * @param {T[]} ls
+ * @param {number} i
+ * @param {T} newValue
+ */
+export const listBuilderSet = (ls, i, newValue) => {
+  if (0 <= i && i <= ls.length) {
+    ls[i] = newValue;
+  }
+}
+
+/**
+ * Implements extension method ListBuilder::removeLast
+ * @template T
+ * @param {T[]} ls
+ * @param {number} index
+ * @param {number | null} [removeCount]
+ * @param {T[] | null} [newValues]
+ * @returns {Readonly<T[]>}
+ */
+export const listBuilderSplice = (ls, index, removeCount, newValues) => {
+  // Missing count is all, but explicit undefined is 0, so give explicit length.
+  if (removeCount == null) {
+    removeCount = ls.length;
+  }
+  return Object.freeze(ls.splice(index, removeCount, ...(newValues || [])));
+}
+
+/**
+ * Implements extension method ListBuilder::toList
+ * @template T
+ * @param {T[]} ls
+ * @returns {Readonly<T[]>}
+ */
+export const listBuilderToList = (ls) => {
+  return Object.freeze(ls.slice());
+}
+
+/**
+ * Implements extension method Listed::slice
+ * @template T
+ * @param {T[]} ls
+ * @param {number} startInclusive
+ * @param {number} endExclusive
+ * @returns {Readonly<T[]>}
+ */
+export const listedSlice = (ls, startInclusive, endExclusive) => {
+  if (startInclusive < 0) {
+    startInclusive = 0;
+  }
+  if (endExclusive < 0) {
+    endExclusive = 0;
+  }
+  return Object.freeze(ls.slice(startInclusive, endExclusive));
+}

package/mapped.js

@@ -0,0 +1,216 @@
+import { pairConstructor } from "./pair.js";
+import { bubble } from "./core.js";
+
+/**
+ * @typedef {import("./pair.js").Pair} Pair
+ */
+
+/**
+ * @template K, V
+ * @extends {Map<K, V>}
+ */
+export 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);
+  }
+}
+
+/**
+ * @template K, V
+ * @param {Pair<K, V>} entries
+ * @returns {Map<K, V>}
+ */
+export const mapConstructor = (entries) => {
+  return Object.freeze(new FreezeMap(entries));
+}
+
+/**
+ * @template K, V
+ * @param {Map<K, V>} entries
+ * @returns {Map<K, V>}
+ */
+export const mapBuilderConstructor = (entries) => {
+  return new Map();
+}
+
+/**
+ * @template K, V
+ * @param {Map<K, V>} builder
+ * @param {K} key
+ * @returns {V}
+ */
+export const mapBuilderRemove = (builder, key) => {
+  const result = builder.get(key);
+  if (builder.delete(key)) {
+    return result;
+  } else {
+    bubble();
+  }
+}
+
+/**
+ * @template K, V
+ * @param {Map<K, V>} builder
+ * @param {K} key
+ * @param {V} value
+ */
+export const mapBuilderSet = (builder, key, value) => {
+  builder.set(key, value);
+}
+
+/**
+ * @template K, V
+ * @param {Map<K, V>} builder
+ * @returns {FreezeMap<K, V>}
+ */
+export const mappedToMap = (mapped) => {
+  if (mapped instanceof FreezeMap) {
+    return mapped;
+  }
+  return Object.freeze(new FreezeMap(mapped));
+}
+
+/**
+ * @template K, V
+ * @param {Map<K, V>} mapped
+ * @returns {Readonly<FreezeMap<K, V>>}
+ */
+export const mapBuilderToMap = (mapped) => {
+  return Object.freeze(new FreezeMap(mapped));
+}
+
+/**
+ * @template K, V
+ * @param {Map<K, V>} mapped
+ * @returns {Map<K, V>}
+ */
+export const mappedToMapBuilder = (mapped) => {
+  return new Map(mapped);
+}
+
+////////////
+// Mapped //
+////////////
+
+/**
+ * @template K, V
+ * @param {Map<K, V>} map
+ * @returns {number}
+ */
+export const mappedLength = (map) => {
+  return map.size;
+}
+
+/**
+ * @template K, V
+ * @param {Map<K, V>} map
+ * @param {K} key
+ * @returns {V}
+ */
+export const 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) {
+    bubble();
+  }
+  return result;
+}
+
+/**
+ * @template K, V
+ * @param {Map<K, V>} map
+ * @param {K} key
+ * @param {V} fallback
+ * @returns {V}
+ */
+export const mappedGetOr = (map, key, fallback) => {
+  return map.get(key) ?? fallback;
+}
+
+/**
+ * @template K, V
+ * @param {Map<K, V>} map
+ * @param {K} key
+ * @returns {boolean}
+ */
+export const mappedHas = (map, key) => {
+  return map.has(key);
+}
+
+/**
+ * @template K, V
+ * @param {Map<K, V>} map
+ * @returns {Readonly<K[]>}
+ */
+export const mappedKeys = (map) => {
+  return Object.freeze(Array.prototype.slice.call(map.keys()));
+}
+
+/**
+ * @template K, V
+ * @param {Map<K, V>} map
+ * @returns {Readonly<V[]>}
+ */
+export const mappedValues = (map) => {
+  return Object.freeze(Array.prototype.slice.call(map.values()));
+}
+
+/**
+ * @template K, V
+ * @param {Map<K, V>} map
+ * @returns {Readonly<Readonly<Pair<K, V>>[]>}
+ */
+export const mappedToList = (map) => {
+  return Object.freeze(Array.from(map, ([key, value]) => pairConstructor(key, value)));
+}
+
+/**
+ * @template K, V, R
+ * @param {Map<K, V>} map
+ * @param {(value: K) => R} func
+ * @returns {Readonly<R[]>}
+ */
+export const mappedToListWith = (map, func) => {
+  return Object.freeze(Array.from(map, ([key, value]) => func(key, value)));
+}
+
+/**
+ * @template K, V, R
+ * @param {Map<K, V>} map
+ * @returns {Readonly<Pair<K, V>>[]}
+ */
+export const mappedToListBuilder = (map) => {
+  return Object.freeze(Array.from(map, ([key, value]) => pairConstructor(key, value)));
+}
+
+/**
+ * @template K, V, R
+ * @param {Map<K, V>} map
+ * @param {(value: K) => R} func
+ * @returns {Readonly<R[]>}
+ */
+export const mappedToListBuilderWith = (map, func) => {
+  return Object.freeze(Array.from(map, ([key, value]) => func(key, value)));
+}
+
+/**
+ * @template K, V
+ * @param {Map<K, V>} map
+ * @param {(key: K, value: V) => void} func
+ */
+export const mappedForEach = (map, func) => {
+  map.forEach((v, k) => func(k, v));
+}

package/package.json

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

package/pair.js

@@ -0,0 +1,69 @@
+
+/**
+ * @template K, V
+ */
+export class Pair {
+  /** @type {K} */
+  key;
+
+  /** @type {V} */
+  value;
+
+  /**
+   * @param {K} key
+   * @param {V} value
+   */
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+  }
+
+  /**
+   * The key held by this pair.
+   * @returns {K}
+   */
+  get key() {
+    return this.key;
+  }
+
+  /**
+   * The value held by this pair.
+   * @returns {V}
+   */
+  get value() {
+    return this.value;
+  }
+
+  /**
+   * The first index is the same as the key.
+   * @returns {K}
+   */
+  get [0]() {
+    return this.key;
+  }
+
+  /**
+   * The second index is the same as the value.
+   * @returns {V}
+   */
+  get [1]() {
+    return this.value;
+  }
+
+  /**
+   * @returns {2}
+   */
+  get length() {
+    return 2;
+  }
+}
+
+/**
+ * @template K, V
+ * @param {K} key
+ * @param {V} value
+ * @returns {Readonly<Pair<K, V>>}
+ */
+export const pairConstructor = (key, value) => {
+  return Object.freeze(new Pair(key, value));
+}