tla-ts 0.0.1 → 0.0.3-dev.763cc71

package/src/pretty-print.ts

@@ -0,0 +1,259 @@
+// A port of TLC's tlc2.pprint package, which re-parses a printed value and breaks it across
+// lines of at most 80 columns. TLC prints the original text whenever the parse fails.
+
+import { skipWhile } from "./lexer";
+
+interface PrintedNode {
+  kind: "Constant" | "Set" | "Sequence" | "Record" | "Function" | "Subset" | "Pair";
+  first: number;
+  last: number;
+  children: PrintedNode[];
+}
+
+interface Delimiters {
+  open: string;
+  close: string;
+  pad: string;
+  separator: string;
+  divider: string;
+  dividerPad: string;
+}
+
+const WIDTH = 80;
+
+const DELIMITERS: Record<string, Delimiters> = {
+  Set: { open: "{ ", close: " }", pad: "  ", separator: ",", divider: "", dividerPad: "" },
+  Sequence: { open: "<< ", close: " >>", pad: "   ", separator: ",", divider: "", dividerPad: "" },
+  Subset: { open: "SUBSET ", close: " ", pad: " ", separator: ",", divider: "", dividerPad: "" },
+  Function: {
+    open: "( ",
+    close: " )",
+    pad: "  ",
+    separator: " @@",
+    divider: " :>",
+    dividerPad: "    ",
+  },
+  Record: {
+    open: "[ ",
+    close: " ]",
+    pad: "  ",
+    separator: ",",
+    divider: " |->",
+    dividerPad: "    ",
+  },
+};
+
+const isWhitespace = (character: string | undefined) => {
+  if (character === undefined) return false;
+  const code = character.charCodeAt(0);
+  return (
+    (code >= 0x09 && code <= 0x0d) ||
+    (code >= 0x1c && code <= 0x20) ||
+    code === 0x1680 ||
+    (code >= 0x2000 && code <= 0x200a && code !== 0x2007) ||
+    code === 0x2028 ||
+    code === 0x2029 ||
+    code === 0x205f ||
+    code === 0x3000
+  );
+};
+
+const isDigit = (character: string | undefined) =>
+  character !== undefined && /^\p{Nd}$/u.test(character);
+
+const isLetterOrDigit = (character: string | undefined) =>
+  character !== undefined && /^[\p{L}\p{Nd}]$/u.test(character);
+
+const parsePrinted = (text: string) => {
+  const skipWhitespace = (index: number) => {
+    const end = skipWhile(text, index, isWhitespace);
+    return text[end] === undefined ? undefined : end;
+  };
+
+  const parseItems = (
+    kind: PrintedNode["kind"],
+    first: number,
+    start: number,
+    close: string,
+    parseItem: (index: number) => PrintedNode | undefined,
+    separator: string,
+  ) => {
+    const node: PrintedNode = { kind, first, last: first, children: [] };
+    const position = { index: skipWhitespace(start) };
+    while (position.index !== undefined && text[position.index] !== close) {
+      const item = parseItem(position.index);
+      if (!item) return undefined;
+      node.children.push(item);
+      const afterItem = skipWhitespace(item.last + 1);
+      if (afterItem === undefined) return undefined;
+      const afterSeparator = text.startsWith(separator, afterItem)
+        ? afterItem + separator.length
+        : afterItem;
+      position.index = skipWhitespace(afterSeparator);
+    }
+    if (position.index === undefined) return undefined;
+    node.last = position.index;
+    return node;
+  };
+
+  const parsePair = (index: number, divider: string): PrintedNode | undefined => {
+    const left = parse(index);
+    if (!left) return undefined;
+    const dividerIndex = skipWhitespace(left.last + 1);
+    if (dividerIndex === undefined || !text.startsWith(divider, dividerIndex)) return undefined;
+    const rightIndex = skipWhitespace(dividerIndex + divider.length);
+    const right = rightIndex === undefined ? undefined : parse(rightIndex);
+    if (!right) return undefined;
+    return { kind: "Pair", first: index, last: right.last, children: [left, right] };
+  };
+
+  const parseInterval = (first: number): PrintedNode | undefined => {
+    const lowEnd = skipWhile(text, first, isDigit);
+    if (!text.startsWith("..", lowEnd) || !isDigit(text[lowEnd + 2])) return undefined;
+    return {
+      kind: "Constant",
+      first,
+      last: skipWhile(text, lowEnd + 2, isDigit) - 1,
+      children: [],
+    };
+  };
+
+  const parseConstant = (first: number): PrintedNode | undefined => {
+    const character = text[first];
+    if (character === '"') {
+      const closing = text.indexOf('"', first + 1);
+      return closing === -1 ? undefined : { kind: "Constant", first, last: closing, children: [] };
+    }
+    const interval = isDigit(character) ? parseInterval(first) : undefined;
+    if (interval) return interval;
+    if (character === "-") {
+      if (first + 1 >= text.length) return undefined;
+      return {
+        kind: "Constant",
+        first,
+        last: skipWhile(text, first + 1, isDigit) - 1,
+        children: [],
+      };
+    }
+    if (!isLetterOrDigit(character)) return undefined;
+    return {
+      kind: "Constant",
+      first,
+      last: skipWhile(text, first, isLetterOrDigit) - 1,
+      children: [],
+    };
+  };
+
+  const parse = (index: number): PrintedNode | undefined => {
+    const first = skipWhitespace(index);
+    if (first === undefined) return undefined;
+    switch (text[first]) {
+      case "{":
+        return parseItems("Set", first, first + 1, "}", parse, ",");
+      case "<": {
+        const node = parseItems("Sequence", first, first + 2, ">", parse, ",");
+        if (!node || node.last + 1 >= text.length) return undefined;
+        return { ...node, last: node.last + 1 };
+      }
+      case "[":
+        return parseItems("Record", first, first + 1, "]", (item) => parsePair(item, "|->"), ",");
+      case "(":
+        return parseItems("Function", first, first + 1, ")", (item) => parsePair(item, ":>"), "@@");
+      default: {
+        if (!text.startsWith("SUBSET", first)) return parseConstant(first);
+        const elementIndex = skipWhitespace(first + 6);
+        const element = elementIndex === undefined ? undefined : parse(elementIndex);
+        return element
+          ? { kind: "Subset", first, last: element.last, children: [element] }
+          : undefined;
+      }
+    }
+  };
+
+  return parse(0);
+};
+
+export const prettyPrint = (text: string) => {
+  const tree = text.length === 0 ? undefined : parsePrinted(text);
+  if (!tree || tree.last < text.length - 1) return text;
+
+  const getText = (node: PrintedNode) => text.slice(node.first, node.last + 1);
+  const getLength = (node: PrintedNode) => node.last - node.first + 1;
+
+  const format = (
+    node: PrintedNode,
+    columnWidth: number,
+    trailerWidth: number,
+    leftPad: string,
+  ): string | undefined => {
+    if (getLength(node) <= columnWidth - trailerWidth || node.kind === "Constant") {
+      return getText(node);
+    }
+    if (node.kind === "Pair") return undefined;
+    const delimiters = DELIMITERS[node.kind];
+    const innerWidth = columnWidth - Math.max(delimiters.open.length, delimiters.pad.length);
+    const innerTrailer = trailerWidth + delimiters.close.length;
+    const innerPad = leftPad + delimiters.pad;
+    const inner =
+      node.kind === "Function" || node.kind === "Record"
+        ? formatPairs(node.children, innerWidth, innerTrailer, innerPad, delimiters)
+        : formatItems(node.children, innerWidth, innerTrailer, innerPad, delimiters.separator);
+    return inner === undefined ? undefined : delimiters.open + inner + delimiters.close;
+  };
+
+  const formatItems = (
+    items: PrintedNode[],
+    columnWidth: number,
+    trailerWidth: number,
+    leftPad: string,
+    separator: string,
+  ) => {
+    const parts = items.map((item, index) => {
+      const isLast = index === items.length - 1;
+      const formatted = format(
+        item,
+        columnWidth,
+        isLast ? trailerWidth : separator.length,
+        leftPad,
+      );
+      return formatted === undefined || isLast ? formatted : `${formatted}${separator}\n${leftPad}`;
+    });
+    return parts.includes(undefined) ? undefined : parts.join("");
+  };
+
+  const formatPairs = (
+    pairs: PrintedNode[],
+    columnWidth: number,
+    trailerWidth: number,
+    leftPad: string,
+    delimiters: Delimiters,
+  ) => {
+    const parts = pairs.map((pair, index) => {
+      const isLast = index === pairs.length - 1;
+      const left = pair.children[0];
+      const right = pair.children[1];
+      const ending = isLast ? "" : `${delimiters.separator}\n${leftPad}`;
+      const pairLength = getLength(left) + delimiters.divider.length + 1 + getLength(right);
+      const fitsOnOneLine = isLast
+        ? pairLength <= columnWidth - trailerWidth
+        : pairLength + delimiters.separator.length <= columnWidth;
+      if (fitsOnOneLine) return `${getText(left)}${delimiters.divider} ${getText(right)}${ending}`;
+      const formattedLeft =
+        getLength(left) + delimiters.divider.length <= columnWidth
+          ? getText(left)
+          : format(left, columnWidth, trailerWidth + delimiters.divider.length, leftPad);
+      const formattedRight = format(
+        right,
+        columnWidth - delimiters.dividerPad.length,
+        isLast ? trailerWidth : delimiters.separator.length,
+        leftPad + delimiters.dividerPad,
+      );
+      return formattedLeft === undefined || formattedRight === undefined
+        ? undefined
+        : `${formattedLeft}${delimiters.divider}\n${leftPad}${delimiters.dividerPad}${formattedRight}${ending}`;
+    });
+    return parts.includes(undefined) ? undefined : parts.join("");
+  };
+
+  return format(tree, WIDTH, 0, "") ?? text;
+};

package/src/randomization.ts

@@ -1,14 +1,12 @@
 import { defineStateOperator, getValue } from "./builtins";
-import { TlaEvaluationError } from "./errors";
+import { TlaEvaluationError, TlaModuleError } from "./errors";
 import type { Builtin, BuiltinArgument } from "./evaluate";
 import type { CheckerRuntime } from "./runtime";
+import { getRandomSubset, type JavaRandom } from "./tlc-random";
 import {
-  createRecord,
   createSet,
-  createSortedFunction,
   createTuple,
   formatValue,
-  getCardinality,
   isEmptySet,
   isEnumerable,
   isSetValue,
@@ -16,105 +14,48 @@ import {
   type Value,
 } from "./values";
 
-const describeArgument = (position: string, name: string, expected: string, value: string) =>
-  new TlaEvaluationError(
+const createArgumentError = (position: string, name: string, expected: string, value: string) =>
+  new TlaModuleError(
     `The ${position} argument of ${name} should be a ${expected}, but instead it is:\n${value}`,
   );
 
 const getCount = (value: Value, position: string, name: string) => {
   if (typeof value !== "number" || value < 0) {
-    throw describeArgument(position, name, "nonnegative integer", formatValue(value));
+    throw createArgumentError(position, name, "nonnegative integer", formatValue(value));
   }
   return value;
 };
 
 const getFiniteElements = (value: Value, position: string, name: string, expected: string) => {
   if (!isSetValue(value) || !isEnumerable(value)) {
-    throw describeArgument(position, name, expected, formatValue(value));
+    throw createArgumentError(position, name, expected, formatValue(value));
   }
   return toFiniteSet(value).elements;
 };
 
-const getMixedRadixElement = (sets: Value[], index: number) => {
-  const lists = sets.map((set) => toFiniteSet(set).elements);
-  return lists.reduceRight<{ remaining: number; elements: Value[] }>(
-    (current, list) => ({
-      remaining: Math.floor(current.remaining / list.length),
-      elements: [list[current.remaining % list.length], ...current.elements],
-    }),
-    { remaining: index, elements: [] },
-  ).elements;
-};
-
-const getElementAt = (set: Value, index: number): Value => {
-  if (typeof set === "object" && set.kind === "Interval") return set.low + index;
-  if (typeof set === "object" && set.kind === "ProductSet") {
-    return createTuple(getMixedRadixElement(set.factors, index));
-  }
-  if (typeof set === "object" && set.kind === "RecordSet") {
-    const values = getMixedRadixElement(set.sets, index);
-    return createRecord(
-      set.names.map((name, position): [string, Value] => [name, values[position]]),
-    );
-  }
-  if (typeof set === "object" && set.kind === "FunctionSet") {
-    const domain = toFiniteSet(set.domain).elements;
-    return createSortedFunction(
-      domain,
-      getMixedRadixElement(
-        domain.map(() => set.range),
-        index,
-      ),
-    );
-  }
-  return toFiniteSet(set).elements[index];
-};
-
-const getSampleSize = (set: Value): number => {
-  if (isEmptySet(set)) return 0;
-  if (typeof set === "object" && set.kind === "ProductSet") {
-    return set.factors.reduce<number>((size, factor) => size * getSampleSize(factor), 1);
-  }
-  if (typeof set === "object" && set.kind === "RecordSet") {
-    return set.sets.reduce<number>((size, factor) => size * getSampleSize(factor), 1);
-  }
-  if (typeof set === "object" && set.kind === "FunctionSet") {
-    return getSampleSize(set.range) ** getCardinality(set.domain);
-  }
-  return getCardinality(set);
-};
-
-const pickSubset = (set: Value, count: number, random: () => number) => {
-  const size = getSampleSize(set);
-  const indices = new Set<number>();
-  while (indices.size < Math.min(count, size)) indices.add(Math.floor(random() * size));
-  return [...indices].map((index) => getElementAt(set, index));
-};
-
-const tossSubsets = (elements: Value[], picks: number, probability: number, random: () => number) =>
+// SubsetValue.CoinTossingSubsetEnumerator: each pick keeps each element with the probability.
+const tossSubsets = (elements: Value[], picks: number, probability: number, random: JavaRandom) =>
   createSet(
-    Array.from({ length: picks }, () => createSet(elements.filter(() => random() < probability))),
+    Array.from({ length: picks }, () =>
+      createSet(elements.filter(() => random.nextDouble() < probability)),
+    ),
   );
 
-const checkPicks = (picks: number, size: number, name: string) => {
-  if (size < 31 && picks > 2 ** size) {
-    throw describeArgument(
-      "first",
-      name,
-      `nonnegative integer that is smaller than the subset's size of 2^${size}`,
-      String(picks),
-    );
-  }
-};
-
 const getRandomSetOfSubsets = (args: BuiltinArgument[], runtime: CheckerRuntime) => {
   const name = "RandomSetOfSubsets";
   const picks = getCount(getValue(args, 0, name), "first", name);
   const size = getCount(getValue(args, 1, name), "second", name);
   const elements = getFiniteElements(getValue(args, 2, name), "third", name, "finite set");
-  checkPicks(picks, elements.length, name);
+  if (elements.length < 31 && picks > 2 ** elements.length) {
+    throw createArgumentError(
+      "first",
+      name,
+      `nonnegative integer that is smaller than the subset's size of 2^${elements.length}`,
+      String(picks),
+    );
+  }
   if (elements.length < size) {
-    throw describeArgument(
+    throw createArgumentError(
       "second",
       name,
       "nonnegative integer in range 0..Cardinality(S)",
@@ -125,7 +66,7 @@ const getRandomSetOfSubsets = (args: BuiltinArgument[], runtime: CheckerRuntime)
     elements,
     picks,
     elements.length === 0 ? 0 : size / elements.length,
-    runtime.random,
+    runtime.getRandom(),
   );
 };
 
@@ -133,7 +74,7 @@ export const createRandomizationOperators = (runtime: CheckerRuntime): Builtin[]
   defineStateOperator("RandomSubset", 2, (args) => {
     const count = getValue(args, 0, "RandomSubset");
     if (typeof count !== "number") {
-      throw describeArgument("first", "RandomSubset", "nonnegative integer", formatValue(count));
+      throw createArgumentError("first", "RandomSubset", "nonnegative integer", formatValue(count));
     }
     if (count < 0) {
       throw new TlaEvaluationError(
@@ -142,9 +83,9 @@ export const createRandomizationOperators = (runtime: CheckerRuntime): Builtin[]
     }
     const set = getValue(args, 1, "RandomSubset");
     if (!isSetValue(set) || (!isEmptySet(set) && !isEnumerable(set))) {
-      throw describeArgument("second", "RandomSubset", "a finite set", formatValue(set));
+      throw createArgumentError("second", "RandomSubset", "a finite set", formatValue(set));
     }
-    return createSet(pickSubset(set, count, runtime.random));
+    return createSet(getRandomSubset(count, set, runtime.getRandom()));
   }),
   defineStateOperator("RandomSetOfSubsets", 3, (args) => getRandomSetOfSubsets(args, runtime)),
   defineStateOperator("TestRandomSetOfSubsets", 3, (args) =>
@@ -155,34 +96,4 @@ export const createRandomizationOperators = (runtime: CheckerRuntime): Builtin[]
       ),
     ),
   ),
-  defineStateOperator("RandomSubsetSet", 3, (args) => {
-    const name = "RandomSubsetSetProbability";
-    const picks = getCount(getValue(args, 0, "RandomSubsetSet"), "first", name);
-    const text = getValue(args, 1, "RandomSubsetSet");
-    if (typeof text !== "string") {
-      throw describeArgument(
-        "second",
-        name,
-        "string literal representing a probability",
-        formatValue(text),
-      );
-    }
-    const probability = Number(text);
-    if (text.trim() === "" || Number.isNaN(probability) || probability < 0 || probability > 1) {
-      throw describeArgument(
-        "second",
-        name,
-        "string literal does not represent a parsable probability",
-        formatValue(text),
-      );
-    }
-    const elements = getFiniteElements(
-      getValue(args, 2, "RandomSubsetSet"),
-      "third",
-      name,
-      "finite set",
-    );
-    checkPicks(picks, elements.length, name);
-    return tossSubsets(elements, picks, probability, runtime.random);
-  }),
 ];