tla-ts 0.0.3-dev.949cce6 → 0.0.3-dev.9b15ea6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (80) hide show
  1. package/dist/cli.cjs +1 -1
  2. package/dist/cli.js +1 -1
  3. package/dist/index.cjs +1 -1
  4. package/dist/index.d.cts +146 -8
  5. package/dist/index.d.ts +146 -8
  6. package/dist/index.js +1 -1
  7. package/dist/parallel-worker.cjs +1 -1
  8. package/dist/parallel-worker.js +2 -2
  9. package/dist/parallel.cjs +1 -1
  10. package/dist/parallel.js +2 -2
  11. package/dist/run-cli.cjs +1351 -20
  12. package/dist/run-cli.js +1351 -20
  13. package/dist/transfer.cjs +86 -28
  14. package/dist/transfer.js +86 -28
  15. package/package.json +5 -1
  16. package/src/ast.ts +48 -6
  17. package/src/bags.ts +4 -7
  18. package/src/builtins.ts +29 -11
  19. package/src/bundled-modules.ts +3 -3
  20. package/src/canonical.ts +4 -3
  21. package/src/check.ts +1352 -215
  22. package/src/cli.ts +8 -1
  23. package/src/codegen.ts +68 -18
  24. package/src/config.ts +252 -179
  25. package/src/environment.ts +451 -129
  26. package/src/errors.ts +217 -3
  27. package/src/evaluate.ts +724 -117
  28. package/src/exit-codes.ts +5 -4
  29. package/src/index.ts +1 -0
  30. package/src/instances.ts +4 -2
  31. package/src/java-overrides.ts +104 -25
  32. package/src/levels.ts +183 -37
  33. package/src/lexer.ts +14 -1
  34. package/src/live-check.ts +211 -89
  35. package/src/liveness.ts +192 -65
  36. package/src/obligation-expression.ts +2 -2
  37. package/src/obligation-source.ts +2 -0
  38. package/src/parallel-worker.ts +8 -3
  39. package/src/parallel.ts +56 -5
  40. package/src/parser.ts +423 -126
  41. package/src/pcal-ast.ts +770 -0
  42. package/src/pcal-parse.ts +1523 -0
  43. package/src/pcal-tokenize.ts +516 -0
  44. package/src/pcal-translate.ts +1230 -0
  45. package/src/pcal-validate.ts +454 -0
  46. package/src/randomization.ts +24 -7
  47. package/src/resolve.ts +1363 -405
  48. package/src/run-cli.ts +1167 -155
  49. package/src/runtime.ts +16 -0
  50. package/src/sany-builtins.ts +147 -0
  51. package/src/sany-generator.ts +3112 -0
  52. package/src/sany-levels.ts +1208 -0
  53. package/src/sany-lexer.ts +545 -0
  54. package/src/sany-linter.ts +122 -0
  55. package/src/sany-modules.ts +1398 -0
  56. package/src/sany-nodes.ts +463 -0
  57. package/src/sany-parse-error.ts +2161 -0
  58. package/src/sany-report.ts +354 -0
  59. package/src/sany-selectors.ts +738 -0
  60. package/src/sany-source.ts +248 -0
  61. package/src/sany-xml.ts +1017 -0
  62. package/src/spec-description.ts +26 -7
  63. package/src/standard-modules.ts +203 -146
  64. package/src/standard-ranges.ts +116 -0
  65. package/src/state-graph.ts +29 -6
  66. package/src/subexpressions.ts +221 -161
  67. package/src/substitution-levels.ts +38 -17
  68. package/src/successors.ts +162 -114
  69. package/src/symmetry.ts +180 -52
  70. package/src/tableau.ts +4 -2
  71. package/src/tlc-ext.ts +13 -17
  72. package/src/tlc-messages.ts +329 -0
  73. package/src/tlc-module.ts +46 -18
  74. package/src/tlc-order.ts +56 -6
  75. package/src/tlc-random.ts +28 -3
  76. package/src/tlc-replay.ts +655 -0
  77. package/src/tlc-version.ts +18 -0
  78. package/src/transfer.ts +15 -3
  79. package/src/value-sources.ts +29 -0
  80. package/src/values.ts +684 -204
package/src/values.ts CHANGED
@@ -1,5 +1,6 @@
1
1
  import { TlaEvaluationError, TlaModuleError } from "./errors";
2
2
  import { prettyPrint } from "./pretty-print";
3
+ import type { TlcVersion } from "./tlc-version";
3
4
 
4
5
  export interface ModelValue {
5
6
  kind: "ModelValue";
@@ -29,6 +30,7 @@ export interface FunctionValue {
29
30
  hash: number;
30
31
  fingerprint: number;
31
32
  writtenKeys: Value[] | undefined;
33
+ functionClass: FunctionClass | undefined;
32
34
  }
33
35
 
34
36
  export interface IntervalValue {
@@ -76,10 +78,17 @@ export interface SetOperationValue {
76
78
  right: Value;
77
79
  }
78
80
 
81
+ // TLC prints a set filter as its bound names and the location of its predicate.
82
+ interface FilteredSetSource {
83
+ names: string;
84
+ predicate: string;
85
+ }
86
+
79
87
  export interface FilteredSetValue {
80
88
  kind: "FilteredSet";
81
89
  base: Value;
82
90
  test: (element: Value) => boolean;
91
+ source?: FilteredSetSource;
83
92
  }
84
93
 
85
94
  // UNION S when some element of S isn't a set enumeration. TLC enumerates it only when it has to.
@@ -103,6 +112,7 @@ export interface LazyFunctionValue {
103
112
  domain: Value;
104
113
  apply: (argument: Value) => Value;
105
114
  source?: LazyFunctionSource;
115
+ functionClass?: FunctionClass;
106
116
  }
107
117
 
108
118
  export type Value =
@@ -137,10 +147,9 @@ export const isSetValue = (value: Value) =>
137
147
  value.kind !== "Function" &&
138
148
  value.kind !== "LazyFunction";
139
149
 
140
- export type ReducibleSet = SetValue | MixedSetValue | IntervalValue;
141
-
142
- // TLC reduces a set enumeration or an interval eagerly, and keeps every other set lazy.
143
- export const isReducible = (value: Value): value is ReducibleSet =>
150
+ // TLC's Reducible values, SetEnumValue and IntervalValue, which combine with another set element by
151
+ // element.
152
+ export const isReducibleSet = (value: Value): value is SetValue | MixedSetValue | IntervalValue =>
144
153
  typeof value === "object" &&
145
154
  (value.kind === "Set" || value.kind === "MixedSet" || value.kind === "Interval");
146
155
 
@@ -182,7 +191,7 @@ export const getWrittenPairs = (functionValue: FunctionValue): [Value, Value][]
182
191
  };
183
192
 
184
193
  export const createWrittenRecord = (names: Value[], range: Value[], writtenNames: Value[]) =>
185
- setWrittenOrder(createSortedFunction(names, range), writtenNames);
194
+ setWrittenOrder(createSortedRecord(names, range), writtenNames);
186
195
 
187
196
  // TLC sorts a value it compares even with itself, and every value inside it, so a value it has
188
197
  // hashed or fingerprinted is already sorted.
@@ -267,7 +276,10 @@ const checkModelValueTypes = (left: Value, right: Value, isEquality: boolean) =>
267
276
 
268
277
  // TLC orders strings and model value names by when it first interned the text, so every
269
278
  // check sets the order of its spec's strings before it builds any value.
270
- const stringOrder = { ranks: Object.create(null) as Record<string, number>, size: 0 };
279
+ const stringOrder: { ranks: Record<string, number>; size: number } = {
280
+ ranks: Object.create(null),
281
+ size: 0,
282
+ };
271
283
 
272
284
  export const setStringOrder = (texts: Iterable<string>) => {
273
285
  stringOrder.ranks = Object.create(null);
@@ -276,6 +288,14 @@ export const setStringOrder = (texts: Iterable<string>) => {
276
288
  for (const text of texts) rankString(text);
277
289
  };
278
290
 
291
+ // TLC 1.7.4 prints an empty function that isn't a tuple with a space between its brackets, and
292
+ // looks a key up in a function differently, so every check also sets the version its values follow.
293
+ const valueVersion = { is174: false };
294
+
295
+ export const setValueVersion = (version: TlcVersion | undefined) => {
296
+ valueVersion.is174 = version === "1.7.4";
297
+ };
298
+
279
299
  export const rankString = (text: string) => {
280
300
  if (stringOrder.ranks[text] === undefined) stringOrder.ranks[text] = stringOrder.size++;
281
301
  return text;
@@ -378,7 +398,7 @@ export const compareValues = (left: Value, right: Value): number => {
378
398
  `Attempted to compare ${describeKind(left)} ${formatValue(left)} with ${describeKind(right)} ${formatValue(right)}`,
379
399
  );
380
400
  }
381
- if (isLeftSet) return compareSets(toFiniteSet(left), toComparedSet(right));
401
+ if (isLeftSet) return compareSets(toFiniteSet(left), toFiniteSet(right));
382
402
  return compareFunctions(toFiniteFunction(left), toFiniteFunction(right));
383
403
  }
384
404
  if (typeof left === "number" && typeof right === "number") return left - right;
@@ -422,9 +442,85 @@ export const createSortedFunction = (domain: Value[], range: Value[]): FunctionV
422
442
  hash: 0,
423
443
  fingerprint: 0,
424
444
  writtenKeys: undefined,
445
+ functionClass: undefined,
425
446
  });
426
447
 
448
+ // TLC words a failed function application by the Java class of the function: FcnLambdaValue for
449
+ // [x \in S |-> e], TupleValue for <<...>> and what the sequence operators build, RecordValue for
450
+ // [a |-> e], and FcnRcdValue for any other function.
451
+ export type FunctionClass = "lambda" | "tuple" | "record";
452
+
453
+ // Whether a lambda exists for markFingerprinted to find, so that a spec without one skips the walk.
454
+ const lambdaPresence = { isPresent: false };
455
+
456
+ export const setFunctionClass = <FunctionLike extends FunctionValue | LazyFunctionValue>(
457
+ functionValue: FunctionLike,
458
+ functionClass: FunctionClass | undefined,
459
+ ) => {
460
+ if (functionClass === "lambda") lambdaPresence.isPresent = true;
461
+ if (functionClass !== undefined) functionValue.functionClass = functionClass;
462
+ return functionValue;
463
+ };
464
+
465
+ export const getFunctionClass = (value: Value) =>
466
+ typeof value === "object" && (value.kind === "Function" || value.kind === "LazyFunction")
467
+ ? value.functionClass
468
+ : undefined;
469
+
470
+ export const markLambdaFunction = <FunctionLike extends FunctionValue | LazyFunctionValue>(
471
+ functionValue: FunctionLike,
472
+ ) => setFunctionClass(functionValue, "lambda");
473
+
474
+ const fingerprintedValues = new WeakSet<ObjectValue>();
475
+
476
+ // The lazy sets TLC has cached the elements of. TLC caches a set as the receiver of compareTo,
477
+ // equals, size, and fingerPrint, not as their argument, and enumerates the sets an uncached one
478
+ // combines, duplicates and all.
479
+ const cachedSets = new WeakSet<ObjectValue>();
480
+
481
+ // Whether the spec has built a UNION or \cup set, the sets that stream duplicates, so that a spec
482
+ // without one skips tracking what TLC caches.
483
+ const streamedSetPresence = { isPresent: false };
484
+
485
+ export const markStreamedSet = <Streamed extends UnionValue | SetOperationValue>(
486
+ value: Streamed,
487
+ ) => {
488
+ streamedSetPresence.isPresent = true;
489
+ return value;
490
+ };
491
+
492
+ const cacheSet = (value: Value) => {
493
+ if (streamedSetPresence.isPresent && typeof value === "object") cachedSets.add(value);
494
+ };
495
+
496
+ // FcnLambdaValue#fingerPrint caches the FcnRcdValue the function enumerates to, which applies it
497
+ // from then on, so a function TLC has fingerprinted is no longer a lambda.
498
+ export const markFingerprinted = (value: Value): void => {
499
+ if (
500
+ (!lambdaPresence.isPresent && !streamedSetPresence.isPresent) ||
501
+ typeof value !== "object" ||
502
+ fingerprintedValues.has(value)
503
+ ) {
504
+ return;
505
+ }
506
+ fingerprintedValues.add(value);
507
+ if (value.kind === "Function") {
508
+ if (value.functionClass === "lambda") value.functionClass = undefined;
509
+ value.domain.forEach(markFingerprinted);
510
+ value.range.forEach(markFingerprinted);
511
+ } else if (value.kind === "Set" || value.kind === "MixedSet") {
512
+ value.elements.forEach(markFingerprinted);
513
+ } else if (isSetValue(value) && isEnumerable(value)) {
514
+ cacheSet(value);
515
+ toFiniteSet(value).elements.forEach(markFingerprinted);
516
+ }
517
+ };
518
+
519
+ export const createSortedRecord = (names: Value[], range: Value[]) =>
520
+ setFunctionClass(createSortedFunction(names, range), "record");
521
+
427
522
  export const valuesEqual = (left: Value, right: Value): boolean => {
523
+ cacheSet(left);
428
524
  if (left === right) {
429
525
  if (writtenOrderUse.isUsed) forgetWrittenOrder(left);
430
526
  return left !== ANY_SET || compareAny(left);
@@ -498,28 +594,36 @@ export const valuesEqual = (left: Value, right: Value): boolean => {
498
594
  return compareValues(left, right) === 0;
499
595
  };
500
596
 
501
- const areSameValues = (left: Value[], right: Value[]) =>
502
- left === right ||
503
- (left.length === right.length &&
504
- left.every((element, index) => isSameValue(element, right[index])));
505
-
506
- export const isSameValue = (left: Value, right: Value): boolean => {
507
- if (left === right) return true;
508
- if (typeof left !== "object" || typeof right !== "object") return false;
509
- if (left.kind === "Set" && right.kind === "Set")
510
- return (
511
- (left.hash === 0 || right.hash === 0 || left.hash === right.hash) &&
512
- areSameValues(left.elements, right.elements)
513
- );
514
- if (left.kind === "Function" && right.kind === "Function")
515
- return (
516
- (left.hash === 0 || right.hash === 0 || left.hash === right.hash) &&
517
- areSameValues(left.domain, right.domain) &&
518
- areSameValues(left.range, right.range)
519
- );
520
- return getValueKey(left) === getValueKey(right);
597
+ // TLC prints and words errors about an equal function by its Java class, so a value can stand for
598
+ // another in a state only if each function in it has the same class.
599
+ const createSameValueCheck = (isClassSensitive: boolean) => {
600
+ const areSameValues = (left: Value[], right: Value[]) =>
601
+ left === right ||
602
+ (left.length === right.length && left.every((element, index) => isSame(element, right[index])));
603
+ const isSame = (left: Value, right: Value): boolean => {
604
+ if (left === right) return true;
605
+ if (typeof left !== "object" || typeof right !== "object") return false;
606
+ if (left.kind === "Set" && right.kind === "Set")
607
+ return (
608
+ (left.hash === 0 || right.hash === 0 || left.hash === right.hash) &&
609
+ areSameValues(left.elements, right.elements)
610
+ );
611
+ if (left.kind === "Function" && right.kind === "Function")
612
+ return (
613
+ (!isClassSensitive || left.functionClass === right.functionClass) &&
614
+ (left.hash === 0 || right.hash === 0 || left.hash === right.hash) &&
615
+ areSameValues(left.domain, right.domain) &&
616
+ areSameValues(left.range, right.range)
617
+ );
618
+ return getValueKey(left) === getValueKey(right);
619
+ };
620
+ return isSame;
521
621
  };
522
622
 
623
+ export const isSameValue = createSameValueCheck(false);
624
+
625
+ export const isInterchangeableValue = createSameValueCheck(true);
626
+
523
627
  // The comparisons above fail with their own messages. These follow the compareTo and equals
524
628
  // methods of TLC's Java value classes, which word a failure by the class of the left operand, so a
525
629
  // failed comparison runs again through them to fail as TLC does.
@@ -675,7 +779,7 @@ const compareFunctionLikeTlc = (left: FunctionValue | LazyFunctionValue, right:
675
779
  compareElementsLikeTlc(functionValue.range, tuple)
676
780
  );
677
781
  }
678
- if (left.kind === "Function" && functionValue.domain.every((key) => typeof key === "string")) {
782
+ if (getFunctionClass(left) === "record") {
679
783
  const record = toTlcRecord(right);
680
784
  if (!record) {
681
785
  if (isModelValue(right)) return compareModelValueWith(right, left);
@@ -793,7 +897,7 @@ const equalsFunctionLikeTlc = (left: FunctionValue | LazyFunctionValue, right: V
793
897
  equalsElementsLikeTlc(functionValue.range, tuple)
794
898
  );
795
899
  }
796
- if (left.kind === "Function" && functionValue.domain.every((key) => typeof key === "string")) {
900
+ if (getFunctionClass(left) === "record") {
797
901
  const record = toTlcRecord(right);
798
902
  if (!record) {
799
903
  if (isModelValue(right)) return equalsModelValueWith(right, left);
@@ -845,42 +949,75 @@ const equalsLikeTlc = (left: Value, right: Value): boolean => {
845
949
  const sortLikeTlc = (elements: Value[]) => {
846
950
  const sorted: Value[] = [];
847
951
  for (const element of elements) {
848
- const bounds = { low: 0, high: sorted.length, comparison: 1 };
849
- while (bounds.low < bounds.high) {
850
- const middle = bounds.low + ((bounds.high - bounds.low) >> 1);
851
- bounds.comparison = compareLikeTlc(element, sorted[middle]);
852
- if (bounds.comparison === 0) break;
853
- if (bounds.comparison < 0) bounds.high = middle;
854
- else bounds.low = middle + 1;
855
- }
856
- if (bounds.comparison !== 0) sorted.splice(bounds.low, 0, element);
952
+ const found = searchLikeTlc(element, sorted);
953
+ if (!found.isFound) sorted.splice(found.index, 0, element);
857
954
  }
858
955
  return sorted;
859
956
  };
860
957
 
861
- // TLC checks membership in a set enumeration it hasn't sorted element by element.
958
+ // Calls a method of a value as TLC does, whose failure the value heads when it has a source.
959
+ const callTracedMethod = <Result>(receiver: Value, method: () => Result) => {
960
+ const sets = setTrace.sets;
961
+ if (sets === undefined) return method();
962
+ sets.push(receiver);
963
+ const result = method();
964
+ sets.pop();
965
+ return result;
966
+ };
967
+
968
+ // ValueVec.search on sorted elements: a binary search with compareTo, which ends where the element
969
+ // is or would go.
970
+ const searchLikeTlc = (element: Value, sorted: Value[]) => {
971
+ const bounds = { low: 0, high: sorted.length };
972
+ while (bounds.low < bounds.high) {
973
+ const middle = bounds.low + ((bounds.high - bounds.low) >> 1);
974
+ const comparison = callTracedMethod(element, () => compareLikeTlc(element, sorted[middle]));
975
+ if (comparison === 0) return { index: middle, isFound: true };
976
+ if (comparison < 0) bounds.high = middle;
977
+ else bounds.low = middle + 1;
978
+ }
979
+ return { index: bounds.low, isFound: false };
980
+ };
981
+
982
+ // TLC checks membership in a set enumeration it hasn't sorted element by element, with the equals
983
+ // method of each member.
862
984
  const isElementOfLikeTlc = (element: Value, elements: Value[]) =>
863
- elements.some((member) => equalsLikeTlc(member, element));
985
+ elements.some((member) => callTracedMethod(member, () => equalsLikeTlc(member, element)));
864
986
 
865
- export const isEqualLikeTlc = (left: Value, right: Value) => {
866
- try {
867
- return valuesEqual(left, right);
868
- } catch (error) {
869
- if (!(error instanceof TlaEvaluationError)) throw error;
870
- return equalsLikeTlc(left, right);
987
+ // The sets TLC has normalized, whose membership ValueVec.search checks by binary search with
988
+ // compareTo instead of element by element.
989
+ const normalizedSets = new WeakSet<SetValue>();
990
+
991
+ // IValue.deepNormalize, which TLC applies to the constants of the config and the constant
992
+ // definitions it computes as it starts.
993
+ export const markNormalized = (value: Value): void => {
994
+ if (typeof value !== "object") return;
995
+ if (value.kind === "Set") {
996
+ normalizedSets.add(value);
997
+ value.elements.forEach(markNormalized);
998
+ }
999
+ if (value.kind === "Function") {
1000
+ value.domain.forEach(markNormalized);
1001
+ value.range.forEach(markNormalized);
871
1002
  }
872
1003
  };
873
1004
 
874
- // TLC sorts a set by comparing each element with the ones before it, so the later element converts
875
- // a lazy set it compares and caches it.
1005
+ export const isEqualLikeTlc = (left: Value, right: Value) =>
1006
+ computeLikeTlcOnFailure(
1007
+ () => valuesEqual(left, right),
1008
+ () => equalsLikeTlc(left, right),
1009
+ );
1010
+
876
1011
  const isStrictlySorted = (elements: Value[]) => {
877
1012
  for (let index = 1; index < elements.length; index++) {
878
- if (compareValues(elements[index], elements[index - 1]) <= 0) return false;
1013
+ if (compareValues(elements[index - 1], elements[index]) >= 0) return false;
879
1014
  }
880
1015
  return true;
881
1016
  };
882
1017
 
883
1018
  export const createSet = (elements: Value[]): SetValue => {
1019
+ // ValueVec.sort compares each element after the first with those before it.
1020
+ for (let index = 1; index < elements.length; index++) cacheSet(elements[index]);
884
1021
  if (elements.length < 2 || isStrictlySorted(elements)) return createSortedSet(elements);
885
1022
  const sorted = [...elements].sort(compareValues);
886
1023
  const unique = [sorted[0]];
@@ -892,14 +1029,11 @@ export const createSet = (elements: Value[]): SetValue => {
892
1029
 
893
1030
  // TLC builds a set enumeration without sorting it, so one whose elements it can't compare still
894
1031
  // evaluates.
895
- export const createEnumeratedSet = (elements: Value[]): SetValue | MixedSetValue => {
896
- try {
897
- return createSet(elements);
898
- } catch (error) {
899
- if (!(error instanceof TlaEvaluationError)) throw error;
900
- return { kind: "MixedSet", elements };
901
- }
902
- };
1032
+ export const createEnumeratedSet = (elements: Value[]): SetValue | MixedSetValue =>
1033
+ computeLikeTlcOnFailure<SetValue | MixedSetValue>(
1034
+ () => createSet(elements),
1035
+ () => ({ kind: "MixedSet", elements }),
1036
+ );
903
1037
 
904
1038
  export const EMPTY_SET = createSortedSet([]);
905
1039
 
@@ -978,12 +1112,15 @@ export const unionSorted = (left: SetValue, right: SetValue): SetValue => {
978
1112
  }
979
1113
  if (added.length === 0) return left;
980
1114
  const union = createSortedSet(merged);
981
- if (left.hash !== 0) {
1115
+ if (left.hash !== 0 && left.hash !== UNFINGERPRINTABLE_HASH) {
982
1116
  let hash = left.hash;
983
- for (let index = 0; index < added.length; index++) {
984
- hash = (hash + getElementContribution(added[index])) | 0;
1117
+ let index = 0;
1118
+ for (; index < added.length; index++) {
1119
+ const elementHash = getValueHash(added[index]);
1120
+ if (elementHash === UNFINGERPRINTABLE_HASH) break;
1121
+ hash = (hash + getElementContribution(elementHash)) | 0;
985
1122
  }
986
- union.hash = hash;
1123
+ if (index === added.length) union.hash = hash;
987
1124
  }
988
1125
  if (left.fingerprint !== 0) {
989
1126
  let fingerprint = left.fingerprint;
@@ -1068,12 +1205,13 @@ const getIntervalValue = (high: number): IntervalValue => {
1068
1205
  };
1069
1206
 
1070
1207
  export const createTuple = (elements: Value[]): FunctionValue =>
1071
- createSortedFunction(getIntervalDomain(elements.length), elements);
1208
+ setFunctionClass(createSortedFunction(getIntervalDomain(elements.length), elements), "tuple");
1072
1209
 
1073
- export const createRecord = (fields: [string, Value][]): FunctionValue => createFunction(fields);
1210
+ export const createRecord = (fields: [string, Value][]): FunctionValue =>
1211
+ setFunctionClass(createFunction(fields), "record");
1074
1212
 
1075
1213
  // TLC's Enumerable classes: every set except the ones it implements in Java.
1076
- const isTlcEnumerable = (value: Value) => isSetValue(value) && !isOverriddenSet(value);
1214
+ export const isTlcEnumerable = (value: Value) => isSetValue(value) && !isOverriddenSet(value);
1077
1215
 
1078
1216
  const formatUnion = (value: UnionValue, isStrict = false) =>
1079
1217
  `UNION(${formatValue(value.base, isStrict)})`;
@@ -1196,6 +1334,41 @@ const advanceCombination = (indices: number[], length: number) => {
1196
1334
  return false;
1197
1335
  };
1198
1336
 
1337
+ // TLC enumerates SUBSET S lazily, by size and then in the order of S, so a quantifier that finds
1338
+ // its witness early never builds the rest. For a power set too large to build, the elements are
1339
+ // computed in that order as a loop reads them.
1340
+ export const getLazySubsets = (value: Value): Value[] | undefined => {
1341
+ if (typeof value !== "object" || value.kind !== "Subset" || isOverriddenSet(value.base)) {
1342
+ return undefined;
1343
+ }
1344
+ const base = toFiniteSet(value.base).elements;
1345
+ if (base.length <= MAXIMUM_ENUMERATED_SUBSET_BASE) return undefined;
1346
+ const cursor = { index: -1, indices: [0] };
1347
+ const getSubset = (index: number) => {
1348
+ if (index <= cursor.index) cursor.index = -1;
1349
+ while (cursor.index < index) {
1350
+ if (cursor.index === -1) cursor.indices = [];
1351
+ else if (!advanceCombination(cursor.indices, base.length)) {
1352
+ cursor.indices = Array.from({ length: cursor.indices.length + 1 }, (_, item) => item);
1353
+ }
1354
+ cursor.index++;
1355
+ }
1356
+ return createSortedSet(cursor.indices.map((item) => base[item]));
1357
+ };
1358
+ const length = 2 ** base.length;
1359
+ const isIndex = (property: string | symbol) =>
1360
+ typeof property === "string" && /^\d+$/.test(property) && Number(property) < length;
1361
+ return new Proxy<Value[]>([], {
1362
+ get: (target, property, receiver) => {
1363
+ if (property === "length") return length;
1364
+ return isIndex(property)
1365
+ ? getSubset(Number(property))
1366
+ : Reflect.get(target, property, receiver);
1367
+ },
1368
+ has: (target, property) => isIndex(property) || Reflect.has(target, property),
1369
+ });
1370
+ };
1371
+
1199
1372
  const getSortedSubsets = (base: Value[]) => {
1200
1373
  const subsets: Value[] = [];
1201
1374
  for (let size = 0; size <= base.length; size++) {
@@ -1207,7 +1380,30 @@ const getSortedSubsets = (base: Value[]) => {
1207
1380
  return subsets;
1208
1381
  };
1209
1382
 
1210
- const enumerateSet = (value: Value): Value[] => {
1383
+ // The Enumerator of a set of records or tuples enumerates its sets in turn and stops at the first
1384
+ // empty one, which leaves the product empty. Later versions of TLC decide that the set is empty
1385
+ // before they enumerate it.
1386
+ const getComponentElements = (
1387
+ sets: Value[],
1388
+ getElements: (set: Value) => Value[],
1389
+ describeUnenumerable: (set: Value, index: number) => string,
1390
+ ) => {
1391
+ const lists: Value[][] = [];
1392
+ for (let index = 0; index < sets.length; index++) {
1393
+ const set = sets[index];
1394
+ if (isOverriddenSet(set)) throw new TlaEvaluationError(describeUnenumerable(set, index));
1395
+ const elements = getElements(set);
1396
+ if (elements.length === 0) return [[]];
1397
+ lists.push(elements);
1398
+ }
1399
+ return lists;
1400
+ };
1401
+
1402
+ // getElements enumerates the sets a set of functions, records, or tuples combines.
1403
+ const enumerateSet = (
1404
+ value: Value,
1405
+ getElements = (set: Value) => toFiniteSet(set).elements,
1406
+ ): Value[] => {
1211
1407
  if (typeof value !== "object")
1212
1408
  throw new TlaEvaluationError(`Expected a set but found ${formatValue(value)}`);
1213
1409
  switch (value.kind) {
@@ -1221,61 +1417,63 @@ const enumerateSet = (value: Value): Value[] => {
1221
1417
  return elements;
1222
1418
  }
1223
1419
  case "Subset": {
1224
- if (isOverriddenSet(value.base)) getCardinality(value.base);
1225
- const base = toFiniteSet(value.base).elements;
1226
- if (base.length > MAXIMUM_ENUMERATED_SUBSET_BASE) {
1420
+ // SubsetValue.toSetEnum sizes the set before it enumerates it, and enumerates only the empty
1421
+ // set of a value of size 0, a function with an empty domain among them.
1422
+ if (getCardinality(value.base) === 0) return getSortedSubsets([]);
1423
+ if (!isSetValue(value.base)) {
1227
1424
  throw new TlaEvaluationError(
1228
- `SUBSET of a set with ${base.length} elements is too large to enumerate`,
1425
+ `Attempted to compute the value of an expression of form\nSUBSET S, but S is a non-enumerable value:\n${prettyPrint(formatValue(value.base))}`,
1229
1426
  );
1230
1427
  }
1428
+ const base = toFiniteSet(value.base).elements;
1429
+ if (base.length > MAXIMUM_ENUMERATED_SUBSET_BASE) {
1430
+ throw new TlaEvaluationError(describeOverflow(value));
1431
+ }
1231
1432
  return getSortedSubsets(base);
1232
1433
  }
1233
1434
  case "FunctionSet": {
1234
- if (isEmptySet(value)) return [];
1435
+ if (!valueVersion.is174 && isEmptySet(value)) return [];
1235
1436
  if (isOverriddenSet(value.domain)) {
1236
1437
  throw new TlaEvaluationError(
1237
1438
  `Attempted to enumerate a set of the form [D -> R],but the domain D:\n${formatValue(value.domain)}\ncannot be enumerated.`,
1238
1439
  );
1239
1440
  }
1240
1441
  const domain = getFunctionDomain(value.domain);
1241
- if (domain.length > 0 && isOverriddenSet(value.range)) {
1442
+ // TLC 1.7.4 requires an enumerable range even of an empty domain.
1443
+ if ((domain.length > 0 || valueVersion.is174) && isOverriddenSet(value.range)) {
1242
1444
  throw new TlaEvaluationError(
1243
1445
  `Attempted to enumerate a set of the form [D -> R],but the range R:\n${formatValue(value.range)}\ncannot be enumerated.`,
1244
1446
  );
1245
1447
  }
1246
- const range = domain.length === 0 ? [] : toFiniteSet(value.range).elements;
1448
+ const range = domain.length === 0 ? [] : getElements(value.range);
1247
1449
  return getCartesianProduct(domain.map(() => range)).map((combination): Value =>
1248
1450
  createSortedFunction(domain, combination),
1249
1451
  );
1250
1452
  }
1251
1453
  case "RecordSet": {
1252
- if (isEmptySet(value)) return [];
1253
- const fields = value.sets.map((set, index) => {
1254
- if (isOverriddenSet(set)) {
1255
- throw new TlaEvaluationError(
1256
- `Attempted to enumerate a set of the form [l1 : v1, ..., ln : vn],\nbut can't enumerate the value of the \`${value.names[index]}' field:\n${formatValue(set)}`,
1257
- );
1258
- }
1259
- return toFiniteSet(set).elements;
1260
- });
1454
+ if (!valueVersion.is174 && isEmptySet(value)) return [];
1455
+ const fields = getComponentElements(
1456
+ value.sets,
1457
+ getElements,
1458
+ (set, index) =>
1459
+ `Attempted to enumerate a set of the form [l1 : v1, ..., ln : vn],\nbut can't enumerate the value of the \`${value.names[index]}' field:\n${formatValue(set)}`,
1460
+ );
1261
1461
  return getCartesianProduct(fields).map((combination) =>
1262
1462
  createRecord(value.names.map((name, index): [string, Value] => [name, combination[index]])),
1263
1463
  );
1264
1464
  }
1265
1465
  case "ProductSet": {
1266
- if (isEmptySet(value)) return [];
1267
- const factors = value.factors.map((factor, index) => {
1268
- if (isOverriddenSet(factor)) {
1269
- throw new TlaEvaluationError(
1270
- `Attempted to enumerate a set of the form s1 \\X s2 ... \\X sn,\nbut can't enumerate s${index}:\n${formatValue(factor)}`,
1271
- );
1272
- }
1273
- return toFiniteSet(factor).elements;
1274
- });
1466
+ if (!valueVersion.is174 && isEmptySet(value)) return [];
1467
+ const factors = getComponentElements(
1468
+ value.factors,
1469
+ getElements,
1470
+ (factor, index) =>
1471
+ `Attempted to enumerate a set of the form s1 \\X s2 ... \\X sn,\nbut can't enumerate s${index}:\n${formatValue(factor)}`,
1472
+ );
1275
1473
  return getCartesianProduct(factors).map(createTuple);
1276
1474
  }
1277
1475
  case "FilteredSet":
1278
- if (isOverriddenSet(value.base)) {
1476
+ if (!isSetValue(value.base) || isOverriddenSet(value.base)) {
1279
1477
  throw new TlaEvaluationError(
1280
1478
  `Attempted to enumerate { x \\in S : p(x) } when S:\n${formatValue(value.base)}\nis not enumerable`,
1281
1479
  );
@@ -1290,7 +1488,7 @@ const enumerateSet = (value: Value): Value[] => {
1290
1488
  case "SetOperation": {
1291
1489
  if (
1292
1490
  value.operator === "\\cup" &&
1293
- (isOverriddenSet(value.left) || isOverriddenSet(value.right))
1491
+ (!isTlcEnumerable(value.left) || !isTlcEnumerable(value.right))
1294
1492
  ) {
1295
1493
  throw new TlaEvaluationError(
1296
1494
  `Attempted to enumerate S \\cup T when S:\n${formatValue(value.left)}\nand T:\n${formatValue(value.right)}\nare not both enumerable`,
@@ -1298,21 +1496,21 @@ const enumerateSet = (value: Value): Value[] => {
1298
1496
  }
1299
1497
  if (
1300
1498
  value.operator === "\\cap" &&
1301
- isOverriddenSet(value.left) &&
1302
- isOverriddenSet(value.right)
1499
+ !isTlcEnumerable(value.left) &&
1500
+ !isTlcEnumerable(value.right)
1303
1501
  ) {
1304
1502
  throw new TlaEvaluationError(
1305
1503
  `Attempted to enumerate S \\cap T when neither S:\n${formatValue(value.left)}\nnor T:\n${formatValue(value.right)}\nis enumerable`,
1306
1504
  );
1307
1505
  }
1308
- if (value.operator === "\\" && isOverriddenSet(value.left)) {
1506
+ if (value.operator === "\\" && !isTlcEnumerable(value.left)) {
1309
1507
  throw new TlaEvaluationError(
1310
1508
  `Attempted to enumerate S \\ T when S:\n${formatValue(value.left)}\nis not enumerable.`,
1311
1509
  );
1312
1510
  }
1313
1511
  if (value.operator === "\\cup")
1314
1512
  return unionSorted(toFiniteSet(value.left), toFiniteSet(value.right)).elements;
1315
- const isLeftEnumerated = value.operator === "\\" || isEnumerable(value.left);
1513
+ const isLeftEnumerated = value.operator === "\\" || isTlcEnumerable(value.left);
1316
1514
  const enumerated = isLeftEnumerated ? value.left : value.right;
1317
1515
  const other = isLeftEnumerated ? value.right : value.left;
1318
1516
  return toFiniteSet(enumerated).elements.filter(
@@ -1330,7 +1528,6 @@ const enumerateSet = (value: Value): Value[] => {
1330
1528
  };
1331
1529
 
1332
1530
  const finiteSets = new WeakMap<ObjectValue, SetValue>();
1333
- const comparedSets = new WeakMap<ObjectValue, SetValue>();
1334
1531
 
1335
1532
  export const toFiniteSet = (value: Value): SetValue => {
1336
1533
  if (typeof value === "object" && value.kind === "Set") return value;
@@ -1339,14 +1536,10 @@ export const toFiniteSet = (value: Value): SetValue => {
1339
1536
  }
1340
1537
  const cached = typeof value === "object" ? finiteSets.get(value) : undefined;
1341
1538
  if (cached) return cached;
1342
- const set =
1343
- (typeof value === "object" ? comparedSets.get(value) : undefined) ?? enumerateFiniteSet(value);
1344
- if (typeof value === "object") finiteSets.set(value, set);
1345
- return set;
1346
- };
1347
-
1348
- const enumerateFiniteSet = (value: Value) => {
1539
+ const sets = setTrace.sets;
1540
+ sets?.push(value);
1349
1541
  const elements = enumerateSet(value);
1542
+ sets?.pop();
1350
1543
  const isSorted =
1351
1544
  typeof value === "object" &&
1352
1545
  (value.kind === "MixedSet" ||
@@ -1356,27 +1549,46 @@ const enumerateFiniteSet = (value: Value) => {
1356
1549
  value.kind === "ProductSet" ||
1357
1550
  value.kind === "FunctionSet" ||
1358
1551
  value.kind === "Subset");
1359
- return isSorted ? createSortedSet(elements) : createSet(elements);
1360
- };
1361
-
1362
- // TLC converts the set a comparison receives as its argument without caching it, so a lazy set
1363
- // compared that way still streams the sets it combines.
1364
- const toComparedSet = (value: Value) => {
1365
- const isStreamed =
1366
- typeof value === "object" &&
1367
- (value.kind === "Union" || value.kind === "SetOperation" || value.kind === "FilteredSet");
1368
- if (!isStreamed || finiteSets.has(value)) return toFiniteSet(value);
1369
- const compared = comparedSets.get(value);
1370
- if (compared) return compared;
1371
- const set = enumerateFiniteSet(value);
1372
- comparedSets.set(value, set);
1552
+ const set = isSorted ? createSortedSet(elements) : createSet(elements);
1553
+ if (typeof value === "object") finiteSets.set(value, set);
1373
1554
  return set;
1374
1555
  };
1375
1556
 
1376
1557
  // TLC's Enumerator for a lazy set streams the sets it combines until the set caches its elements,
1377
1558
  // so an element that two of them share comes up once for each.
1378
1559
  export const getStreamedElements = (value: Value): Value[] => {
1379
- if (typeof value !== "object" || finiteSets.has(value)) return toFiniteSet(value).elements;
1560
+ if (typeof value !== "object" || cachedSets.has(value)) return toFiniteSet(value).elements;
1561
+ const sets = setTrace.sets;
1562
+ sets?.push(value);
1563
+ const elements = streamElements(value);
1564
+ sets?.pop();
1565
+ return elements;
1566
+ };
1567
+
1568
+ const getCombinedSets = (value: ObjectValue) =>
1569
+ value.kind === "ProductSet"
1570
+ ? value.factors
1571
+ : value.kind === "RecordSet"
1572
+ ? value.sets
1573
+ : value.kind === "FunctionSet"
1574
+ ? [value.range]
1575
+ : undefined;
1576
+
1577
+ // Whether a set streams its elements in another order than the normalized set, so that a set of
1578
+ // tuples, records, or functions it is a component of has to stream too.
1579
+ const isStreamedApart = (value: Value): boolean => {
1580
+ if (typeof value !== "object" || cachedSets.has(value)) return false;
1581
+ if (value.kind === "Union") return true;
1582
+ if (value.kind === "FilteredSet") return isStreamedApart(value.base);
1583
+ if (value.kind === "SetOperation") {
1584
+ return (
1585
+ value.operator === "\\cup" || isStreamedApart(value.left) || isStreamedApart(value.right)
1586
+ );
1587
+ }
1588
+ return getCombinedSets(value)?.some(isStreamedApart) ?? false;
1589
+ };
1590
+
1591
+ const streamElements = (value: ObjectValue): Value[] => {
1380
1592
  // TLC streams the sets of a UNION it hasn't enumerated, so a set that appears twice there yields
1381
1593
  // its elements twice.
1382
1594
  if (value.kind === "Union") {
@@ -1387,16 +1599,18 @@ export const getStreamedElements = (value: Value): Value[] => {
1387
1599
  if (value.kind === "FilteredSet" && !isOverriddenSet(value.base)) {
1388
1600
  return getStreamedElements(value.base).filter(value.test);
1389
1601
  }
1602
+ const components = getCombinedSets(value);
1603
+ if (components?.some(isStreamedApart)) return enumerateSet(value, getStreamedElements);
1390
1604
  if (value.kind !== "SetOperation") return toFiniteSet(value).elements;
1391
1605
  if (value.operator === "\\cup") {
1392
- return isOverriddenSet(value.left) || isOverriddenSet(value.right)
1606
+ return !isTlcEnumerable(value.left) || !isTlcEnumerable(value.right)
1393
1607
  ? toFiniteSet(value).elements
1394
1608
  : [...getStreamedElements(value.left), ...getStreamedElements(value.right)];
1395
1609
  }
1396
- const isLeftEnumerated = value.operator === "\\" || isEnumerable(value.left);
1610
+ const isLeftEnumerated = value.operator === "\\" || isTlcEnumerable(value.left);
1397
1611
  const enumerated = isLeftEnumerated ? value.left : value.right;
1398
1612
  const other = isLeftEnumerated ? value.right : value.left;
1399
- if (isOverriddenSet(enumerated)) return toFiniteSet(value).elements;
1613
+ if (!isTlcEnumerable(enumerated)) return toFiniteSet(value).elements;
1400
1614
  return getStreamedElements(enumerated).filter(
1401
1615
  (element) => isElementOf(element, other) === (value.operator === "\\cap"),
1402
1616
  );
@@ -1433,9 +1647,13 @@ export const isEmptySet = (value: Value): boolean => {
1433
1647
  }
1434
1648
  };
1435
1649
 
1436
- const getProductCardinality = (sets: Value[], describe: () => string) =>
1650
+ const getProductCardinality = (
1651
+ sets: Value[],
1652
+ version: TlcVersion | undefined,
1653
+ describe: () => string,
1654
+ ) =>
1437
1655
  sets.reduce<number>((product, set) => {
1438
- const size = product * getCardinality(set);
1656
+ const size = product * getCardinality(set, version);
1439
1657
  if (size > MAXIMUM_INTEGER) throw new TlaEvaluationError(describe());
1440
1658
  return size;
1441
1659
  }, 1);
@@ -1443,9 +1661,25 @@ const getProductCardinality = (sets: Value[], describe: () => string) =>
1443
1661
  const describeOverflow = (value: Value) =>
1444
1662
  `Overflow when computing the number of elements in:\n${formatValue(value)}`;
1445
1663
 
1446
- export const getCardinality = (value: Value): number => {
1447
- if (typeof value !== "object") return toFiniteSet(value).elements.length;
1664
+ // TLC 1.7.4 sizes every component of a set of functions, records, or tuples without first
1665
+ // checking whether one is empty, so an infinite component fails even beside an empty one.
1666
+ export const getCardinality = (value: Value, version?: TlcVersion): number => {
1667
+ if (typeof value !== "object") {
1668
+ const kind =
1669
+ typeof value === "number" ? "integer" : typeof value === "string" ? "string" : "boolean";
1670
+ throw new TlaEvaluationError(
1671
+ `Attempted to compute the number of elements in the ${kind} ${formatValue(value)}.`,
1672
+ );
1673
+ }
1448
1674
  switch (value.kind) {
1675
+ case "ModelValue":
1676
+ throw new TlaEvaluationError(
1677
+ `Attempted to compute the number of elements in the model value ${formatValue(value)}.`,
1678
+ );
1679
+ case "Function":
1680
+ return value.domain.length;
1681
+ case "LazyFunction":
1682
+ return getCardinality(value.domain, version);
1449
1683
  case "Interval": {
1450
1684
  const size = Math.max(0, value.high - value.low + 1);
1451
1685
  if (size > MAXIMUM_INTEGER) {
@@ -1461,16 +1695,19 @@ export const getCardinality = (value: Value): number => {
1461
1695
  `Attempted to compute the number of elements in the overridden value ${formatValue(value)}.`,
1462
1696
  );
1463
1697
  case "Subset": {
1464
- const size = getCardinality(value.base);
1698
+ const size = getCardinality(value.base, version);
1465
1699
  if (size >= 31) throw new TlaEvaluationError(describeOverflow(value));
1466
1700
  return 2 ** size;
1467
1701
  }
1468
1702
  case "FunctionSet": {
1469
- if (isEmptySet(value.domain)) return 1;
1470
- if (isEmptySet(value.range)) return 0;
1471
- const rangeSize = getCardinality(value.range);
1472
- if (rangeSize === 1) return 1;
1473
- const domainSize = getCardinality(value.domain);
1703
+ if (version !== "1.7.4") {
1704
+ if (isEmptySet(value.domain)) return 1;
1705
+ if (isEmptySet(value.range)) return 0;
1706
+ if (getCardinality(value.range, version) === 1) return 1;
1707
+ }
1708
+ const domainSize = getCardinality(value.domain, version);
1709
+ const rangeSize = getCardinality(value.range, version);
1710
+ if (rangeSize <= 1) return domainSize === 0 ? 1 : rangeSize;
1474
1711
  const size = { value: 1 };
1475
1712
  for (let index = 0; index < domainSize; index++) {
1476
1713
  size.value *= rangeSize;
@@ -1479,15 +1716,17 @@ export const getCardinality = (value: Value): number => {
1479
1716
  return size.value;
1480
1717
  }
1481
1718
  case "RecordSet":
1482
- if (isEmptySet(value)) return 0;
1483
- return getProductCardinality(value.sets, () => describeOverflow(value));
1719
+ if (version !== "1.7.4" && isEmptySet(value)) return 0;
1720
+ return getProductCardinality(value.sets, version, () => describeOverflow(value));
1484
1721
  case "ProductSet":
1485
- if (isEmptySet(value)) return 0;
1722
+ if (version !== "1.7.4" && isEmptySet(value)) return 0;
1486
1723
  return getProductCardinality(
1487
1724
  value.factors,
1725
+ version,
1488
1726
  () => `Overflow when computing the number of elements in ${formatValue(value)}`,
1489
1727
  );
1490
1728
  default:
1729
+ cacheSet(value);
1491
1730
  return toFiniteSet(value).elements.length;
1492
1731
  }
1493
1732
  };
@@ -1562,11 +1801,11 @@ export const isFiniteSet = (value: Value): boolean => {
1562
1801
  }
1563
1802
  };
1564
1803
 
1565
- const findIndex = (sortedValues: Value[], target: Value) => {
1804
+ const findIndex = (sortedValues: Value[], target: Value, compare = compareValues) => {
1566
1805
  const bounds = { low: 0, high: sortedValues.length - 1 };
1567
1806
  while (bounds.low <= bounds.high) {
1568
1807
  const middle = (bounds.low + bounds.high) >> 1;
1569
- const comparison = compareValues(sortedValues[middle], target);
1808
+ const comparison = compare(sortedValues[middle], target);
1570
1809
  if (comparison === 0) return middle;
1571
1810
  if (comparison < 0) bounds.low = middle + 1;
1572
1811
  else bounds.high = middle - 1;
@@ -1582,33 +1821,78 @@ export const getSequenceElements = (value: Value): Value[] | undefined => {
1582
1821
  : undefined;
1583
1822
  };
1584
1823
 
1585
- const describeMembership = (element: Value, set: Value) =>
1586
- `Attempted to check if the value ${formatValue(element)} is an element of ${formatValue(set)}`;
1587
-
1588
1824
  const describeNonSetMembership = (element: Value, value: Value) => {
1589
1825
  const prefix = `Attempted to check if the value:\n${formatValue(element)}\nis an element of the`;
1590
1826
  if (!isFunctionValue(value)) return `${prefix} ${describeKind(value)} ${formatValue(value)}`;
1591
- const domain =
1592
- value.kind === "Function" || isEnumerable(value.domain) ? toFiniteFunction(value).domain : [];
1593
- if (domain.length > 0 && domain.every((key) => typeof key === "string")) {
1827
+ const functionClass = getFunctionClass(value);
1828
+ if (functionClass === "record") {
1594
1829
  return `Attempted to check if element:\n${formatValue(element)}\nis in the record:\n${formatValue(value)}`;
1595
1830
  }
1596
- if (domain.every((key, index) => key === index + 1)) {
1597
- return "Attempted to check set membership in a tuple value.";
1598
- }
1831
+ if (functionClass === "tuple") return "Attempted to check set membership in a tuple value.";
1599
1832
  return `${prefix} function ${formatValue(value)}`;
1600
1833
  };
1601
1834
 
1835
+ // The call stack of the replay, which a failed fast path leaves frozen.
1836
+ interface TracedCallStack {
1837
+ expressions: unknown[];
1838
+ isFrozen: boolean;
1839
+ fingerprint?: unknown;
1840
+ }
1841
+
1842
+ // The sets whose membership is being checked or whose elements are being enumerated, and the
1843
+ // members being compared, outermost first, while TLC's CallStackTool replays a computation. A failed
1844
+ // check or enumeration leaves the values it was in, each of which TLC adds to the
1845
+ // FingerprintException when it has a source.
1846
+ export const setTrace: { sets: Value[] | undefined; callStack?: TracedCallStack } = {
1847
+ sets: undefined,
1848
+ };
1849
+
1850
+ // Takes a fast path, and computes as TLC does where it fails. TLC never takes the fast path, so
1851
+ // the failure's leftovers in the replay's trace go first.
1852
+ export const computeLikeTlcOnFailure = <Result>(
1853
+ compute: () => Result,
1854
+ computeLikeTlc: (error: TlaEvaluationError) => Result,
1855
+ ): Result => {
1856
+ const sets = setTrace.sets;
1857
+ const callStack = setTrace.callStack;
1858
+ const depth = sets?.length ?? 0;
1859
+ const trace = callStack && { ...callStack, length: callStack.expressions.length };
1860
+ try {
1861
+ return compute();
1862
+ } catch (error) {
1863
+ if (!(error instanceof TlaEvaluationError)) throw error;
1864
+ if (sets) sets.length = depth;
1865
+ if (callStack && trace) {
1866
+ callStack.expressions.length = trace.length;
1867
+ callStack.isFrozen = trace.isFrozen;
1868
+ callStack.fingerprint = trace.fingerprint;
1869
+ }
1870
+ return computeLikeTlc(error);
1871
+ }
1872
+ };
1873
+
1602
1874
  export const isElementOf = (element: Value, set: Value): boolean => {
1875
+ const sets = setTrace.sets;
1876
+ if (sets === undefined) return isElementOfSet(element, set);
1877
+ sets.push(set);
1878
+ const isElement = isElementOfSet(element, set);
1879
+ sets.pop();
1880
+ return isElement;
1881
+ };
1882
+
1883
+ const isElementOfSet = (element: Value, set: Value): boolean => {
1603
1884
  if (!isSetValue(set)) throw new TlaEvaluationError(describeNonSetMembership(element, set));
1604
1885
  switch (set.kind) {
1605
1886
  case "Set":
1606
- try {
1607
- return findIndex(set.elements, element) !== -1;
1608
- } catch (error) {
1609
- if (!(error instanceof TlaEvaluationError)) throw error;
1610
- return isElementOfLikeTlc(element, set.elements);
1611
- }
1887
+ // SetEnumValue.member compares the element with the set's.
1888
+ cacheSet(element);
1889
+ return computeLikeTlcOnFailure(
1890
+ () => findIndex(set.elements, element) !== -1,
1891
+ () =>
1892
+ normalizedSets.has(set)
1893
+ ? searchLikeTlc(element, set.elements).isFound
1894
+ : isElementOfLikeTlc(element, set.elements),
1895
+ );
1612
1896
  case "MixedSet":
1613
1897
  return isElementOfLikeTlc(element, set.elements);
1614
1898
  case "Interval":
@@ -1632,12 +1916,21 @@ export const isElementOf = (element: Value, set: Value): boolean => {
1632
1916
  return set.name !== "Nat" || (typeof element === "number" && element >= 0);
1633
1917
  }
1634
1918
  case "Subset":
1635
- if (!isSetValue(element)) throw new TlaEvaluationError(describeMembership(element, set));
1919
+ // SubsetValue.member fails on any value that is not Enumerable, model values and the sets a
1920
+ // Java class overrides included.
1921
+ if (!isSetValue(element) || isOverriddenSet(element)) {
1922
+ throw new TlaEvaluationError(
1923
+ `Attempted to check if the non-enumerable value\n${prettyPrint(formatValue(element))}\nis element of\n${prettyPrint(formatValue(set))}`,
1924
+ );
1925
+ }
1636
1926
  return toFiniteSet(element).elements.every((item) => isElementOf(item, set.base));
1637
1927
  case "FunctionSet": {
1638
1928
  if (!isFunctionValue(element)) {
1639
1929
  if (isModelValue(element)) return false;
1640
- throw new TlaEvaluationError(describeMembership(element, set));
1930
+ // SetOfFcnsValue.member prints the element without Values.ppr.
1931
+ throw new TlaEvaluationError(
1932
+ `Attempted to check if \n${formatValue(element)}\nwhich is not a TLC function value, is in the set of functions:\n${prettyPrint(formatValue(set))}`,
1933
+ );
1641
1934
  }
1642
1935
  const functionValue = toFiniteFunction(element);
1643
1936
  const low = getIntervalLow(functionValue.domain);
@@ -1702,7 +1995,10 @@ export const isElementOf = (element: Value, set: Value): boolean => {
1702
1995
  const elements = getSequenceElements(element);
1703
1996
  if (elements === undefined) {
1704
1997
  if (isModelValue(element)) return false;
1705
- throw new TlaEvaluationError(describeMembership(element, set));
1998
+ // Sequences.member raises TLC_MODULE_CHECK_MEMBER_OF.
1999
+ throw new TlaEvaluationError(
2000
+ `Attempted to check if the value:\n${prettyPrint(formatValue(element))}\nis an element of ${prettyPrint(formatValue(set))}.`,
2001
+ );
1706
2002
  }
1707
2003
  return elements.every((item) => isElementOf(item, set.base));
1708
2004
  }
@@ -1735,27 +2031,59 @@ export const toFiniteFunction = (value: Value): FunctionValue => {
1735
2031
  if (typeof value === "object" && value.kind === "LazyFunction") {
1736
2032
  if (!isEnumerable(value.domain)) getCardinality(value.domain);
1737
2033
  const domain = getFunctionDomain(value.domain);
1738
- return createSortedFunction(
1739
- domain,
1740
- domain.map((key) => value.apply(key)),
2034
+ return setFunctionClass(
2035
+ createSortedFunction(
2036
+ domain,
2037
+ domain.map((key) => value.apply(key)),
2038
+ ),
2039
+ getFunctionClass(value),
1741
2040
  );
1742
2041
  }
1743
2042
  throw new TlaEvaluationError(`Expected a function but found ${formatValue(value)}`);
1744
2043
  };
1745
2044
 
1746
- const lambdaFunctions = new WeakSet<ObjectValue>();
1747
-
1748
- export const markLambdaFunction = <FunctionLike extends FunctionValue | LazyFunctionValue>(
1749
- functionValue: FunctionLike,
2045
+ export const describeMissingArgument = (
2046
+ functionValue: Value,
2047
+ argument: Value,
2048
+ version?: TlcVersion,
1750
2049
  ) => {
1751
- lambdaFunctions.add(functionValue);
1752
- return functionValue;
2050
+ const shown = prettyPrint(formatValue(functionValue));
2051
+ const shownArgument = prettyPrint(formatValue(argument));
2052
+ const is174 = version === "1.7.4";
2053
+ switch (getFunctionClass(functionValue)) {
2054
+ case "lambda":
2055
+ return `In applying the function\n${shown},\nthe first argument is:\n${shownArgument}\nwhich is not in its domain.\n`;
2056
+ case "tuple":
2057
+ if (typeof argument !== "number") {
2058
+ return is174
2059
+ ? "Attempted to apply tuple to a non-integer argument."
2060
+ : `Attempted to access tuple at a non integral index: ${shownArgument}`;
2061
+ }
2062
+ return is174
2063
+ ? `Attempted to apply tuple\n${shown}\nto integer ${argument} which is out of domain.`
2064
+ : `Attempted to access index ${argument} of tuple\n${shown}\nwhich is out of bounds.`;
2065
+ case "record":
2066
+ if (typeof argument !== "string") {
2067
+ return is174
2068
+ ? `Attempted to apply record to a non-string value ${shownArgument}.`
2069
+ : `Attempted to access record by a non-string argument: ${shownArgument}`;
2070
+ }
2071
+ return is174
2072
+ ? `Attempted to apply the record\n${shown}\nto nonexistent record field ${argument}.`
2073
+ : `Attempted to access nonexistent field '${argument}' of record\n${shown}`;
2074
+ default:
2075
+ return `Attempted to apply function:\n${shown}\nto argument ${shownArgument}, which is not in the domain of the function.`;
2076
+ }
1753
2077
  };
1754
2078
 
1755
- const describeMissingArgument = (functionValue: Value, argument: Value) =>
1756
- typeof functionValue === "object" && lambdaFunctions.has(functionValue)
1757
- ? `In applying the function\n${prettyPrint(formatValue(functionValue))},\nthe first argument is:\n${prettyPrint(formatValue(argument))}\nwhich is not in its domain.\n`
1758
- : `Attempted to apply function ${formatValue(functionValue)} to ${formatValue(argument)}, which is not in its domain`;
2079
+ // TLC 1.7.4 words a key of the wrong type in an EXCEPT, which selects rather than applies, apart.
2080
+ const describeExceptKey = (functionValue: FunctionValue, argument: Value) => {
2081
+ if (!valueVersion.is174) return describeMissingArgument(functionValue, argument);
2082
+ const shown = prettyPrint(formatValue(argument));
2083
+ return getFunctionClass(functionValue) === "tuple"
2084
+ ? `Attempted to apply tuple to a non-integer argument ${shown}.`
2085
+ : `Attempted to apply record to a non-string argument ${shown}.`;
2086
+ };
1759
2087
 
1760
2088
  const findKeyIndex = (domain: Value[], argument: Value) => {
1761
2089
  const first = domain[0];
@@ -1770,15 +2098,57 @@ const findKeyIndex = (domain: Value[], argument: Value) => {
1770
2098
  return findIndex(domain, argument);
1771
2099
  };
1772
2100
 
2101
+ export const createNonIntegerKeyError = (argument: Value) =>
2102
+ new TlaEvaluationError(
2103
+ `Attempted to apply function with integer domain to the non-integer argument ${prettyPrint(formatValue(argument))}`,
2104
+ );
2105
+
2106
+ // TLC's FcnRcdValue searches a domain this small linearly with equals, and a larger normalized one by
2107
+ // binary search with compareTo.
2108
+ const LINEAR_SEARCH_LIMIT = 32;
2109
+
2110
+ // TLC looks a key up by the Java class of the function: a tuple or a record rejects a key of the
2111
+ // wrong type, and another function rejects a non-integer for a domain it keeps as an interval, which
2112
+ // TLC 1.7.4 doesn't. A key of another type than the domain's keys otherwise fails TLC's comparison.
2113
+ const findKeyIndexLikeTlc = (
2114
+ functionValue: FunctionValue,
2115
+ argument: Value,
2116
+ describeWrongKey: (functionValue: FunctionValue, argument: Value) => string,
2117
+ ) => {
2118
+ const domain = functionValue.domain;
2119
+ if (typeof argument !== typeof domain[0]) {
2120
+ const functionClass = getFunctionClass(functionValue);
2121
+ const keyType =
2122
+ functionClass === "tuple" ? "number" : functionClass === "record" ? "string" : undefined;
2123
+ if (keyType !== undefined && typeof argument !== keyType) {
2124
+ throw new TlaEvaluationError(describeWrongKey(functionValue, argument));
2125
+ }
2126
+ if (keyType === undefined && !valueVersion.is174 && isIntervalDomain(domain)) {
2127
+ throw createNonIntegerKeyError(argument);
2128
+ }
2129
+ }
2130
+ return computeLikeTlcOnFailure(
2131
+ () => findKeyIndex(domain, argument),
2132
+ (error) => {
2133
+ if (valueVersion.is174 || domain.length < LINEAR_SEARCH_LIMIT) {
2134
+ domain.forEach((key) => equalsLikeTlc(key, argument));
2135
+ } else {
2136
+ findIndex(domain, argument, compareLikeTlc);
2137
+ }
2138
+ throw error;
2139
+ },
2140
+ );
2141
+ };
2142
+
1773
2143
  export const applyFunction = (
1774
2144
  functionValue: Value,
1775
2145
  argument: Value,
1776
- describeMissing?: (functionValue: FunctionValue) => string,
2146
+ describeMissing?: (functionValue: FunctionValue, argument: Value) => string,
1777
2147
  ): Value => {
1778
2148
  if (typeof functionValue === "object" && functionValue.kind === "LazyFunction") {
1779
2149
  if (!isElementOf(argument, functionValue.domain)) {
1780
2150
  throw new TlaEvaluationError(
1781
- lambdaFunctions.has(functionValue)
2151
+ getFunctionClass(functionValue) === "lambda"
1782
2152
  ? describeMissingArgument(functionValue, argument)
1783
2153
  : `Attempted to apply a function to ${formatValue(argument)}, which is not in its domain`,
1784
2154
  );
@@ -1790,12 +2160,9 @@ export const applyFunction = (
1790
2160
  `Attempted to apply ${formatValue(functionValue)}, which is not a function`,
1791
2161
  );
1792
2162
  }
1793
- const position = findKeyIndex(functionValue.domain, argument);
1794
- if (position === -1) {
1795
- throw new TlaEvaluationError(
1796
- describeMissing?.(functionValue) ?? describeMissingArgument(functionValue, argument),
1797
- );
1798
- }
2163
+ const describe = describeMissing ?? describeMissingArgument;
2164
+ const position = findKeyIndexLikeTlc(functionValue, argument, describe);
2165
+ if (position === -1) throw new TlaEvaluationError(describe(functionValue, argument));
1799
2166
  return functionValue.range[position];
1800
2167
  };
1801
2168
 
@@ -1824,28 +2191,45 @@ export const updateFunction = (
1824
2191
  if (isLazy) {
1825
2192
  if (!isElementOf(argument, functionValue.domain)) return functionValue;
1826
2193
  const updated = update(functionValue.apply(argument));
1827
- return {
1828
- kind: "LazyFunction",
1829
- domain: functionValue.domain,
1830
- apply: (key) => (isEqualLikeTlc(argument, key) ? updated : functionValue.apply(key)),
1831
- source: functionValue.source,
1832
- };
2194
+ return setFunctionClass<LazyFunctionValue>(
2195
+ {
2196
+ kind: "LazyFunction",
2197
+ domain: functionValue.domain,
2198
+ apply: (key) => (isEqualLikeTlc(argument, key) ? updated : functionValue.apply(key)),
2199
+ source: functionValue.source,
2200
+ },
2201
+ getFunctionClass(functionValue),
2202
+ );
2203
+ }
2204
+ if (!isFunctionValue(functionValue)) {
2205
+ throw new TlaEvaluationError(
2206
+ `Attempted to apply EXCEPT construct to the value ${prettyPrint(formatValue(functionValue))}.`,
2207
+ );
1833
2208
  }
1834
2209
  const finite = toFiniteFunction(functionValue);
1835
- const position = findKeyIndex(finite.domain, argument);
2210
+ const position = findKeyIndexLikeTlc(finite, argument, describeExceptKey);
1836
2211
  if (position === -1) return finite;
1837
2212
  const range = [...finite.range];
1838
2213
  const previous = finite.range[position];
1839
2214
  const next = update(previous);
1840
2215
  range[position] = next;
1841
- const updated = createSortedFunction(finite.domain, range);
2216
+ const updated = setFunctionClass(
2217
+ createSortedFunction(finite.domain, range),
2218
+ getFunctionClass(finite),
2219
+ );
1842
2220
  updated.writtenKeys = finite.writtenKeys;
1843
- if (finite.hash !== 0) {
1844
- const key = finite.domain[position];
1845
- updated.hash =
1846
- previous === next
1847
- ? finite.hash
1848
- : (finite.hash - getEntryContribution(key, previous) + getEntryContribution(key, next)) | 0;
2221
+ if (finite.hash !== 0 && finite.hash !== UNFINGERPRINTABLE_HASH) {
2222
+ const nextHash = getValueHash(next);
2223
+ if (nextHash !== UNFINGERPRINTABLE_HASH) {
2224
+ const keyHash = getValueHash(finite.domain[position]);
2225
+ updated.hash =
2226
+ previous === next
2227
+ ? finite.hash
2228
+ : (finite.hash -
2229
+ getEntryContribution(keyHash, getValueHash(previous)) +
2230
+ getEntryContribution(keyHash, nextHash)) |
2231
+ 0;
2232
+ }
1849
2233
  }
1850
2234
  if (finite.fingerprint !== 0) {
1851
2235
  const key = finite.domain[position];
@@ -1882,32 +2266,103 @@ const hashString = (value: string) => {
1882
2266
  const SET_HASH_SEED = 0x73a5c3e1;
1883
2267
  const FUNCTION_HASH_SEED = 0x66d1b4f7;
1884
2268
 
1885
- const getElementContribution = (element: Value) =>
1886
- finalizeHash((getValueHash(element) + 0x9e3779b9) | 0);
2269
+ const getElementContribution = (elementHash: number) =>
2270
+ finalizeHash((elementHash + 0x9e3779b9) | 0);
2271
+
2272
+ const getEntryContribution = (keyHash: number, valueHash: number) =>
2273
+ finalizeHash((Math.imul(keyHash, 0x27d4eb2d) + valueHash) | 0);
1887
2274
 
1888
- const getEntryContribution = (key: Value, value: Value) =>
1889
- finalizeHash((Math.imul(getValueHash(key), 0x27d4eb2d) + getValueHash(value)) | 0);
2275
+ // The hash of each value that TLC fails to fingerprint, such as Nat or a set that holds it. Calls
2276
+ // with such a value as an argument still share their result, and a state that holds one fails
2277
+ // when TLC fingerprints it.
2278
+ const UNFINGERPRINTABLE_HASH = 0x2f6b1c4d;
1890
2279
 
1891
2280
  const computeValueHash = (value: ObjectValue) => {
1892
2281
  if (value.kind === "ModelValue") return finalizeHash(combineHash(hashString(value.name), 0x6d));
1893
2282
  if (isSetValue(value)) {
1894
- if (!isEnumerable(value)) return hashString(getValueKey(value));
2283
+ if (!isEnumerable(value)) return UNFINGERPRINTABLE_HASH;
1895
2284
  const elements = toFiniteSet(value).elements;
1896
2285
  let hash = SET_HASH_SEED;
1897
2286
  for (let index = 0; index < elements.length; index++) {
1898
- hash = (hash + getElementContribution(elements[index])) | 0;
2287
+ const elementHash = getValueHash(elements[index]);
2288
+ if (elementHash === UNFINGERPRINTABLE_HASH) return UNFINGERPRINTABLE_HASH;
2289
+ hash = (hash + getElementContribution(elementHash)) | 0;
1899
2290
  }
1900
2291
  return hash;
1901
2292
  }
2293
+ if (value.kind === "LazyFunction" && !isEnumerable(value.domain)) return UNFINGERPRINTABLE_HASH;
1902
2294
  const functionValue = toFiniteFunction(value);
1903
2295
  let hash = FUNCTION_HASH_SEED;
1904
2296
  for (let index = 0; index < functionValue.domain.length; index++) {
1905
- hash =
1906
- (hash + getEntryContribution(functionValue.domain[index], functionValue.range[index])) | 0;
2297
+ const keyHash = getValueHash(functionValue.domain[index]);
2298
+ const itemHash = getValueHash(functionValue.range[index]);
2299
+ if (keyHash === UNFINGERPRINTABLE_HASH || itemHash === UNFINGERPRINTABLE_HASH) {
2300
+ return UNFINGERPRINTABLE_HASH;
2301
+ }
2302
+ hash = (hash + getEntryContribution(keyHash, itemHash)) | 0;
1907
2303
  }
1908
2304
  return hash;
1909
2305
  };
1910
2306
 
2307
+ // TLC's fingerPrint enumerates each set and function a value holds, and fails on Nat, Seq(S) and
2308
+ // the like, which it never enumerates.
2309
+ const fingerprintValue = (value: Value): void => {
2310
+ if (typeof value !== "object" || value.kind === "ModelValue") return;
2311
+ if (value.kind === "InfiniteSet" || value.kind === "SequenceSet") {
2312
+ throw new TlaEvaluationError(
2313
+ `TLC has found a state in which the value of a variable contains ${formatValue(value)}`,
2314
+ );
2315
+ }
2316
+ if (isSetValue(value)) {
2317
+ toFiniteSet(value).elements.forEach(fingerprintValue);
2318
+ return;
2319
+ }
2320
+ const functionValue = toFiniteFunction(value);
2321
+ functionValue.domain.forEach(fingerprintValue);
2322
+ functionValue.range.forEach(fingerprintValue);
2323
+ };
2324
+
2325
+ // The error TLC raises as it fingerprints a value: one that hashing the value raises, as for a set
2326
+ // too large to enumerate, or one of a value with the hash of the values TLC fails on.
2327
+ export const getFingerprintError = (value: Value) => {
2328
+ if (typeof value !== "object" || value.kind === "ModelValue") return undefined;
2329
+ try {
2330
+ if (getValueHash(value) === UNFINGERPRINTABLE_HASH) fingerprintValue(value);
2331
+ return undefined;
2332
+ } catch (error) {
2333
+ if (!(error instanceof TlaEvaluationError)) throw error;
2334
+ return error;
2335
+ }
2336
+ };
2337
+
2338
+ // The values a value holds, which TLC fingerprints as it fingerprints the value.
2339
+ export const getHeldValues = (value: ObjectValue): Value[] => {
2340
+ switch (value.kind) {
2341
+ case "Set":
2342
+ case "MixedSet":
2343
+ return value.elements;
2344
+ case "Function":
2345
+ return [...value.domain, ...value.range];
2346
+ case "Subset":
2347
+ case "SequenceSet":
2348
+ case "FilteredSet":
2349
+ case "Union":
2350
+ return [value.base];
2351
+ case "FunctionSet":
2352
+ return [value.domain, value.range];
2353
+ case "RecordSet":
2354
+ return value.sets;
2355
+ case "ProductSet":
2356
+ return value.factors;
2357
+ case "SetOperation":
2358
+ return [value.left, value.right];
2359
+ case "LazyFunction":
2360
+ return [value.domain];
2361
+ default:
2362
+ return [];
2363
+ }
2364
+ };
2365
+
1911
2366
  export const getValueHash = (value: Value): number => {
1912
2367
  if (typeof value === "number") return finalizeHash(value ^ 0x5bd1e995);
1913
2368
  if (typeof value === "boolean") return value ? 0x2b7e1516 : 0x28aed2a6;
@@ -2082,7 +2537,9 @@ const formatLazySet = (value: LazySetValue, isStrict: boolean): string => {
2082
2537
  case "SetOperation":
2083
2538
  return `${format(value.left)} ${value.operator} ${format(value.right)}`;
2084
2539
  case "FilteredSet":
2085
- return `{x \\in ${format(value.base)} : ...}`;
2540
+ return value.source
2541
+ ? `{${value.source.names} \\in ${format(value.base)} : <expression ${value.source.predicate}> }`
2542
+ : `{x \\in ${format(value.base)} : ...}`;
2086
2543
  case "Union":
2087
2544
  return formatUnion(value, isStrict);
2088
2545
  }
@@ -2095,6 +2552,17 @@ const isFieldName = (name: string) =>
2095
2552
  /\p{L}/u.test(name) &&
2096
2553
  (name.length < 4 || !/^[WS]F_/.test(name));
2097
2554
 
2555
+ // FcnLambdaValue#toString prints a function it fails to enumerate as its parameters and body.
2556
+ const toPrintedFunction = (value: LazyFunctionValue) => {
2557
+ if (!isEnumerable(value.domain)) return undefined;
2558
+ try {
2559
+ return toFiniteFunction(value);
2560
+ } catch (error) {
2561
+ if (error instanceof TlaEvaluationError) return undefined;
2562
+ throw error;
2563
+ }
2564
+ };
2565
+
2098
2566
  export const formatValue = (value: Value, isStrict = false, isNormalized = false): string => {
2099
2567
  const format = (inner: Value) => formatValue(inner, isStrict, isNormalized);
2100
2568
  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
@@ -2126,22 +2594,34 @@ export const formatValue = (value: Value, isStrict = false, isNormalized = false
2126
2594
  return `Seq(${format(value.base)})`;
2127
2595
  case "Function":
2128
2596
  case "LazyFunction": {
2129
- if (value.kind === "LazyFunction" && !isEnumerable(value.domain)) {
2130
- const source = value.source;
2597
+ const functionValue = value.kind === "LazyFunction" ? toPrintedFunction(value) : value;
2598
+ if (functionValue === undefined) {
2599
+ const source = value.kind === "LazyFunction" ? value.source : undefined;
2131
2600
  if (!source) return "<function>";
2132
2601
  const parameters = source.parameters
2133
2602
  .map((parameter) => `${parameter.name} \\in ${formatValue(parameter.domain)}`)
2134
2603
  .join(", ");
2135
2604
  return `[${parameters} |-> <expression ${source.body}>]`;
2136
2605
  }
2137
- const functionValue = toFiniteFunction(value);
2606
+ if (
2607
+ functionValue.domain.length === 0 &&
2608
+ valueVersion.is174 &&
2609
+ getFunctionClass(value) !== "tuple"
2610
+ ) {
2611
+ return "<< >>";
2612
+ }
2138
2613
  // TLC normalizes a lambda's domain to print it, but evaluates its body afterward.
2139
2614
  const formatRange = (inner: Value) =>
2140
- formatValue(inner, isStrict, isNormalized && value.kind === "Function");
2615
+ formatValue(inner, isStrict, isNormalized && getFunctionClass(value) !== "lambda");
2141
2616
  if (functionValue.domain.every((key, index) => key === index + 1)) {
2142
2617
  return `<<${functionValue.range.map(formatRange).join(", ")}>>`;
2143
2618
  }
2144
- if (functionValue.domain.every((key) => typeof key === "string" && isFieldName(key))) {
2619
+ // A RecordValue prints as a record whatever its fields, and a FcnRcdValue only if each key
2620
+ // is a name.
2621
+ if (
2622
+ getFunctionClass(value) === "record" ||
2623
+ functionValue.domain.every((key) => typeof key === "string" && isFieldName(key))
2624
+ ) {
2145
2625
  const isSorted =
2146
2626
  isNormalized || functionValue.hash !== 0 || functionValue.fingerprint !== 0;
2147
2627
  const pairs = isSorted