@temperlang/core 0.3.0 → 0.5.0

package/async.js

@@ -0,0 +1,71 @@
+
+/**
+ * @param generatorFactory {() => Generator<unknown>}
+ */
+export const runAsync = (generatorFactory) => {
+  let generator = generatorFactory();
+  setTimeout(() => { generator.next() });
+}
+
+/**
+ * Adapts a generator that takes an extra doAwait function.
+ * This allows adapting `await p` to `yield doAwait(p)`.
+ *
+ * @template T
+ * @template {Array} A The argument list
+ * @param generatorFactory {(doAsync: ((p: Promise<unknown>) => void), ...rest: A) => Generator<T>}
+ * @returns {(...A) => Generator<T>}
+ */
+export const adaptAwaiter = (generatorFactory) => {
+  return (...args) => {
+    /**
+     * @template R
+     * @param {Promise<R>} p
+     */
+    const doAwait = (p) => {
+      p.then(
+        (result) => { generator.next(result) },
+        (error) => { generator.throw(error) },
+      );
+    };
+
+    /** @type {Generator<T>} */
+    const generator = generatorFactory(doAwait, ...args);
+
+    return generator;
+  }
+}
+
+/**
+ * @template R
+ */
+export class PromiseBuilder {
+  /** @type {Promise<R>} */
+  promise;
+  /** @type {(value: (PromiseLike<R> | R)) => void} */
+  resolve;
+  /** @type {(reason?: any) => void} */
+  reject;
+
+  constructor() {
+    this.promise = new Promise(
+      (resolve, reject) => {
+        this.resolve = resolve;
+        this.reject = reject;
+      }
+    );
+  }
+
+  /** @param {R} value */
+  complete(value) {
+    this.resolve(value)
+  }
+
+  /** @param {any?} reason */
+  breakPromise(reason) {
+    this.reject(reason);
+  }
+}
+
+// We might customize this in the future, but actual global console works today.
+export const globalConsole = console;

package/bitvector.js

@@ -0,0 +1,103 @@
+
+/**
+ * @param {number} byte
+ * @returns {string}
+ */
+const byteToString = (byte) => {
+  return byte.toString(2).padStart(8, '0');
+};
+
+/**
+ * @param {number} byte
+ * @returns {boolean[]}
+ */
+const byteToBitArray = (byte) => {
+  const ret = [];
+  for (let i = 0; i < 8; i++) {
+    ret.push((byte & 1) !== 0);
+    byte >>= 1;
+  }
+  return ret;
+};
+
+export class DenseBitVector {
+  /**
+   * @type {Uint8Array}
+   */
+  values;
+
+  constructor() {
+    this.values = new Uint8Array(8);
+  }
+
+  /**
+   * @param {number} index
+   * @returns {boolean}
+   */
+  get(index) {
+    const number = this.values[index >> 3] || 0;
+    return (number & (1 << (index & 7))) !== 0;
+  }
+
+  /**
+   * @param {number} index
+   * @param {boolean} newBitValue
+   */
+  set(index, newBitValue) {
+    let values = this.values;
+    const len = values.byteLength;
+    const key = index >> 3;
+    const shift = index & 7;
+    if (len <= key) {
+      const next = new Uint8Array(len << 1);
+      next.set(values);
+      next[key] = next[key] & ~(1 << shift) | (newBitValue << shift);
+      this.values = next;
+    } else {
+      values[key] = values[key] & ~(1 << shift) | (newBitValue << shift);
+    }
+  }
+
+  /**
+   * @returns {string}
+   */
+  toString() {
+    return `0b${Array.prototype.map.call(this.values, byteToString).join('')}`;
+  }
+
+  /**
+   * @returns {boolean[]}
+   */
+  toJSON() {
+    return Array.prototype.flatMap.call(this.values, byteToBitArray);
+  }
+};
+
+/**
+ * Implements extension method DenseBitVector::constructor
+ * @param {number} capacity
+ * @returns {DenseBitVector}
+ */
+export const denseBitVectorConstructor = (capacity) => {
+  return new DenseBitVector();
+};
+
+/**
+ * Implements extension method DenseBitVector::get
+ * @param {DenseBitVector} denseBitVector
+ * @param {number} index
+ * @returns {boolean}
+ */
+export const denseBitVectorGet = (denseBitVector, index) => {
+  return denseBitVector.get(index);
+};
+
+/**
+ * Implements extension method DenseBitVector::set
+ * @param {DenseBitVector} denseBitVector
+ * @param {number} index
+ * @param {boolean} newBitValue
+ */
+export const denseBitVectorSet = (denseBitVector, index, newBitValue) => {
+  denseBitVector.set(index, newBitValue);
+};

package/check-type.js

@@ -0,0 +1,65 @@
+
+// Export runtime value type checks used for safe casting
+import {bubble} from "./core.js";
+
+/**
+ * @typedef { "bigint" | "boolean" | "number" | "object" | "string" | "symbol" | "undefined" } TypeOf
+ */
+
+/**
+ * @template T
+ * @param {any} x
+ * @param {new(...args: any[]) => T} typeRequirement
+ * @returns {T}
+ */
+export const requireInstanceOf = (x, typeRequirement) => {
+  if (!(x instanceof typeRequirement)) {
+    bubble();
+  }
+  return x;
+};
+
+/**
+ * @template T
+ * @param {T?} x
+ * @returns {T}
+ */
+export const requireNotNull = (x) =>
+  x == null ? bubble() : x
+
+/**
+ * @param {number} x
+ * @returns {number}
+ */
+export const requireIsSafeInteger = (x) => {
+  if (!Number.isSafeInteger(x)) {
+    bubble();
+  }
+  return x;
+};
+
+/**
+ * @template X, Y
+ * @param {X} x
+ * @param {Y} y
+ * @returns {boolean}
+ */
+export const requireSame = (x, y) => {
+  if (x !== y) {
+    bubble();
+  }
+  return x;
+};
+
+/**
+ * @template T
+ * @param {T} x
+ * @param {TypeOf} typeOfString
+ * @returns {T}
+ */
+export const requireTypeOf = (x, typeOfString) => {
+  if (typeof x !== typeOfString) {
+    bubble();
+  }
+  return x;
+};

package/core.js

@@ -0,0 +1,186 @@
+
+/**
+ * @param {number} x
+ * @param {number} y
+ * @returns {number}
+ */
+export const divIntInt = (x, y) => {
+  const result = Math.trunc(x / y);
+  if (!Number.isSafeInteger(result)) {
+    bubble();
+  }
+  /* not NaN or infinite */
+  return result;
+};
+
+/**
+ * @param {number} x
+ * @param {number} y
+ * @returns {number}
+ */
+export const modIntInt = (x, y) => {
+  const result = Math.trunc(x % y);
+  // TODO: is this ever false if `Number.isSafeInteger(x)`?
+  if (!Number.isSafeInteger(result)) {
+    bubble();
+  }
+  /* not NaN or infinite */
+  return result;
+};
+
+/**
+ * Compare two Strings.
+ * @param {string} a
+ * @param {string} b
+ * @return {number}
+ */
+export const cmpString = (a, b) => {
+  if (Object.is(a, b)) {
+    return 0;
+  }
+  const aLen = a.length;
+  const bLen = b.length;
+  const minLen = aLen < bLen ? aLen : bLen;
+  for (let i = 0; i < minLen;) {
+    const ca = a.codePointAt(i);
+    const cb = b.codePointAt(i);
+    const d = ca - cb;
+    if (d !== 0) {
+      return d;
+    }
+    i += ca < 0x10000 ? 1 : 2;
+  }
+  return aLen - bLen;
+};
+
+/**
+ * Compare two Numbers, accounting for signedness of zero.
+ * @param {number} a
+ * @param {number} b
+ * @return {number}
+ */
+export const cmpFloat = (a, b) => {
+  if (Object.is(a, b)) {
+    return 0;
+  }
+  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;
+};
+
+/**
+ * @template {string | number | boolean} T
+ * @param {T} a
+ * @param {T} b
+ * @returns {number}
+ */
+export const cmpGeneric = (a, b) => {
+  if (typeof a === "string" && typeof b === "string") {
+    return cmpString(a, b);
+  }
+  if (typeof a === "number" && typeof b === "number") {
+    return cmpFloat(a, b);
+  }
+  if (typeof a === "boolean" && typeof b === "boolean") {
+    return a - b;
+  }
+  bubble();
+};
+
+/**
+ * @returns {never}
+ */
+export const bubble = () => {
+  throw Error();
+};
+
+/**
+ * TODO Distinguish panic from bubble.
+ *
+ * @returns {never}
+ */
+export const panic = bubble;
+
+/**
+ * @template T
+ * @param {T} a
+ */
+export const print = (a) => {
+  console.log("%s", a);
+};
+
+/**
+ * Takes a JSON adapter and a value that it can adapt.
+ * This is called when JavaScript code calls JSON.stringify on a Temper type instance
+ * that has a zero argument jsonAdapter static method.
+ *
+ * @return any
+ */
+export let marshalToJsonObject = (jsonAdapter, value) => {
+  let stack = [[]];
+  let pendingKey = null;
+  function store(value) {
+    let top = stack[stack.length - 1];
+    if (pendingKey !== null) {
+      top[pendingKey] = value;
+      pendingKey = null;
+    } else if (Array.isArray(top)) {
+      top.push(value);
+    } else {
+      throw new Error();
+    }
+  }
+  let jsonProducer = {
+    interchangeContext: { getHeader() { return null; } },
+
+    startObject() {
+      let o = {};
+      store(o);
+      stack.push(o);
+    },
+    endObject() { stack.pop(); },
+    objectKey(key) { pendingKey = String(key); },
+
+    startArray() {
+      let a = [];
+      store(a);
+      stack.push(a);
+    },
+    endArray() { stack.pop(); },
+
+    nullValue() { store(null); },
+    booleanValue(b) { store(!!b); },
+    intValue(v) { store(Math.trunc(v)); },
+    float64Value(v) { store(+v); },
+    numericTokenValue(s) { store(+s); },
+    stringValue(s) { store(`${s}`); },
+
+    parseErrorReceiver: null,
+  }
+  jsonAdapter.encodeToJson(value, jsonProducer);
+  return stack[0][0];
+};
+
+/** @type {{}} */
+let emptySingleton = Object.freeze(
+  // Prototype for empty
+  Object.create(
+    Object.freeze(
+      Object.create(
+        null,
+        {
+          toString: {
+            value: function toString() { return "(empty)" }
+          }
+        }
+      )
+    )
+  )
+);
+
+/** @return {{}} */
+export function empty() { return emptySingleton }

package/date.js

@@ -0,0 +1,45 @@
+/**
+ * Implements Date::constructor
+ * @param {number} year
+ * @param {number} month
+ * @param {number} day
+ * @returns {Date}
+  */
+export const 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 const 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 const 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());
+};

package/deque.js

@@ -0,0 +1,67 @@
+
+// Implements extension method Deque::add
+import {bubble} from "./core.js";
+
+const DEQUE_NTAKEN = Symbol("Deque::nTaken");
+
+/**
+ * Implements extension method Deque::constructor
+ * @template T
+ * @returns {T[]}
+ */
+export const dequeConstructor = () => {
+  let deque = [];
+  Object.defineProperty(deque, DEQUE_NTAKEN, { value: 0, writable: true });
+  return deque;
+};
+
+/**
+ * Implements extension method Deque::add
+ * @template T
+ * @param {T[]} deque
+ * @param {T} element
+ */
+export const dequeAdd = (deque, element) => {
+  deque.push(element);
+};
+
+/**
+ * Implements extension method Deque::isEmpty
+ * @template T
+ * @param {T[]} deque
+ * @returns {boolean}
+ */
+export const dequeIsEmpty = (deque) => {
+  return deque.length === (deque[DEQUE_NTAKEN] || 0);
+};
+
+/**
+ * Implements extension method Deque::removeFirst
+ * @template T
+ * @param {T[]} deque
+ * @returns {T}
+ */
+export const dequeRemoveFirst = (deque) => {
+  // https://gist.github.com/mikesamuel/444258e7005e8fc9534d9cf274b1df58
+  let nTaken = deque[DEQUE_NTAKEN];
+  let length = deque.length;
+  if (length === nTaken) {
+    deque[DEQUE_NTAKEN] = 0;
+    deque.length = 0;
+    bubble();
+  }
+  let item = deque[nTaken];
+  let nShiftThreshold = (length / 2) | 0;
+  if (nShiftThreshold < 32) {
+    nShiftThreshold = 32;
+  }
+  if (nTaken >= nShiftThreshold) {
+    deque.splice(0, nTaken + 1);
+    deque[DEQUE_NTAKEN] = 0;
+  } else {
+    deque[nTaken] = undefined;
+    deque[DEQUE_NTAKEN] = nTaken + 1;
+  }
+  return item;
+};
+

package/float.js

@@ -0,0 +1,74 @@
+
+// Implements extension method Float64::near
+import {bubble} from "./core.js";
+
+/**
+ * Implements extension method Float64::near
+ * @param {number} x
+ * @param {number} y
+ * @param {number | null} [relTol]
+ * @param {number | null} [absTol]
+ * @returns {boolean}
+ */
+export const float64Near = (x, y, relTol, absTol) => {
+  if (relTol == null) {
+    relTol = 1e-9;
+  }
+  if (absTol == null) {
+    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
+ * @param {number} n
+ * @returns {number}
+ */
+export const float64ToInt = (n) => {
+  const i = float64ToIntUnsafe(n);
+  if (Math.abs(n - i) < 1) {
+    return i;
+  } else {
+    bubble();
+  }
+}
+
+/**
+ * Implements extension method Float64::toIntUnsafe
+ * @param {number} n
+ * @returns {number}
+ */
+export const float64ToIntUnsafe = (n) => {
+  // We are free to do whatever with NaN here.
+  return isNaN(n)
+    ? 0
+    : Math.max(
+      Number.MIN_SAFE_INTEGER,
+      Math.min(Math.trunc(n), Number.MAX_SAFE_INTEGER)
+    );
+}
+
+/**
+ * Implements extension method Float64::toString
+ * @param {number} n
+ * @returns
+ */
+export const float64ToString = (n) => {
+  // TODO(mikesamuel, issue#579): need functional test to nail down
+  // double formatting thresholds.
+  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] || ""}`;
+    }
+  }
+}