tla-ts 0.0.3-dev.79f7ed7 → 0.0.3-dev.852fbc8
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.
- package/README.md +16 -2
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +55 -22
- package/dist/index.d.ts +55 -22
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +2 -2
- package/dist/parallel.cjs +1 -1
- package/dist/parallel.js +2 -2
- package/dist/run-cli.cjs +19 -16
- package/dist/run-cli.js +20 -17
- package/dist/transfer.cjs +37 -16
- package/dist/transfer.js +37 -16
- package/package.json +1 -1
- package/src/ast.ts +93 -0
- package/src/check.ts +511 -99
- package/src/cli-options.ts +11 -5
- package/src/codegen.ts +15 -22
- package/src/config.ts +224 -170
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +116 -28
- package/src/errors.ts +87 -3
- package/src/evaluate.ts +252 -156
- package/src/exit-codes.ts +39 -42
- package/src/instances.ts +16 -15
- package/src/levels.ts +62 -34
- package/src/lexer.ts +5 -1
- package/src/live-check.ts +772 -0
- package/src/liveness.ts +120 -543
- package/src/parallel-worker.ts +7 -3
- package/src/parallel.ts +20 -4
- package/src/parser.ts +33 -11
- package/src/resolve.ts +122 -44
- package/src/run-cli.ts +112 -20
- package/src/runtime.ts +3 -1
- package/src/spec-description.ts +19 -8
- package/src/standard-modules.ts +10 -9
- package/src/state-graph.ts +157 -0
- package/src/subexpressions.ts +10 -10
- package/src/successors.ts +183 -39
- package/src/symmetry.ts +30 -8
- package/src/tableau.ts +51 -24
- package/src/tlc-ext.ts +29 -12
- package/src/tlc-module.ts +14 -33
- package/src/tlc-modules.ts +4 -0
- package/src/tlc-order.ts +25 -7
- package/src/tlc-random.ts +9 -6
- package/src/tlc-summary.ts +20 -5
- package/src/value-sources.ts +29 -0
- package/src/values.ts +179 -57
package/src/values.ts
CHANGED
|
@@ -1,10 +1,12 @@
|
|
|
1
1
|
import { TlaEvaluationError, TlaModuleError } from "./errors";
|
|
2
2
|
import { prettyPrint } from "./pretty-print";
|
|
3
|
+
import { valueSources, withSource } from "./value-sources";
|
|
3
4
|
|
|
4
5
|
export interface ModelValue {
|
|
5
6
|
kind: "ModelValue";
|
|
6
7
|
name: string;
|
|
7
8
|
type: string | undefined;
|
|
9
|
+
rank: number;
|
|
8
10
|
}
|
|
9
11
|
|
|
10
12
|
export interface SetValue {
|
|
@@ -136,6 +138,13 @@ export const isSetValue = (value: Value) =>
|
|
|
136
138
|
value.kind !== "Function" &&
|
|
137
139
|
value.kind !== "LazyFunction";
|
|
138
140
|
|
|
141
|
+
export type ReducibleSet = SetValue | MixedSetValue | IntervalValue;
|
|
142
|
+
|
|
143
|
+
// TLC reduces a set enumeration or an interval eagerly, and keeps every other set lazy.
|
|
144
|
+
export const isReducible = (value: Value): value is ReducibleSet =>
|
|
145
|
+
typeof value === "object" &&
|
|
146
|
+
(value.kind === "Set" || value.kind === "MixedSet" || value.kind === "Interval");
|
|
147
|
+
|
|
139
148
|
export const isFunctionValue = (value: Value): value is FunctionValue | LazyFunctionValue =>
|
|
140
149
|
typeof value === "object" && (value.kind === "Function" || value.kind === "LazyFunction");
|
|
141
150
|
|
|
@@ -264,6 +273,7 @@ const stringOrder = { ranks: Object.create(null) as Record<string, number>, size
|
|
|
264
273
|
export const setStringOrder = (texts: Iterable<string>) => {
|
|
265
274
|
stringOrder.ranks = Object.create(null);
|
|
266
275
|
stringOrder.size = 0;
|
|
276
|
+
modelValues.clear();
|
|
267
277
|
for (const text of texts) rankString(text);
|
|
268
278
|
};
|
|
269
279
|
|
|
@@ -353,7 +363,7 @@ export const compareValues = (left: Value, right: Value): number => {
|
|
|
353
363
|
if (left.type !== undefined && right.type !== undefined) {
|
|
354
364
|
checkModelValueTypes(left, right, false);
|
|
355
365
|
}
|
|
356
|
-
return
|
|
366
|
+
return left.rank - right.rank;
|
|
357
367
|
}
|
|
358
368
|
if (leftKind === "ModelValue" || rightKind === "ModelValue") {
|
|
359
369
|
checkModelValueTypes(left, right, false);
|
|
@@ -369,7 +379,7 @@ export const compareValues = (left: Value, right: Value): number => {
|
|
|
369
379
|
`Attempted to compare ${describeKind(left)} ${formatValue(left)} with ${describeKind(right)} ${formatValue(right)}`,
|
|
370
380
|
);
|
|
371
381
|
}
|
|
372
|
-
if (isLeftSet) return compareSets(toFiniteSet(left),
|
|
382
|
+
if (isLeftSet) return compareSets(toFiniteSet(left), toComparedSet(right));
|
|
373
383
|
return compareFunctions(toFiniteFunction(left), toFiniteFunction(right));
|
|
374
384
|
}
|
|
375
385
|
if (typeof left === "number" && typeof right === "number") return left - right;
|
|
@@ -385,14 +395,15 @@ export const compareValues = (left: Value, right: Value): number => {
|
|
|
385
395
|
|
|
386
396
|
const modelValues = new Map<string, ModelValue>();
|
|
387
397
|
|
|
398
|
+
// A check ranks every model value's name when it creates the value, and creates its own values.
|
|
388
399
|
export const createModelValue = (name: string): ModelValue => {
|
|
389
|
-
rankString(name);
|
|
390
400
|
const known = modelValues.get(name);
|
|
391
401
|
if (known) return known;
|
|
392
402
|
const value: ModelValue = {
|
|
393
403
|
kind: "ModelValue",
|
|
394
404
|
name,
|
|
395
405
|
type: name.length > 2 && name[1] === "_" ? name[0] : undefined,
|
|
406
|
+
rank: getStringRank(name),
|
|
396
407
|
};
|
|
397
408
|
modelValues.set(name, value);
|
|
398
409
|
return value;
|
|
@@ -562,7 +573,7 @@ const equalsModelValueWith = (modelValue: ModelValue, other: Value) => {
|
|
|
562
573
|
|
|
563
574
|
const compareModelValue = (left: ModelValue, right: Value) => {
|
|
564
575
|
const type = getModelValueType(left);
|
|
565
|
-
if (type === undefined) return isModelValue(right) ?
|
|
576
|
+
if (type === undefined) return isModelValue(right) ? left.rank - right.rank : -1;
|
|
566
577
|
if (!isModelValue(right)) {
|
|
567
578
|
throw new TlaEvaluationError(
|
|
568
579
|
`Attempted to compare the typed model value ${formatValue(left)} and non-model value\n${formatValue(right)}`,
|
|
@@ -574,7 +585,7 @@ const compareModelValue = (left: ModelValue, right: Value) => {
|
|
|
574
585
|
`Attempted to compare the differently-typed model values ${formatValue(left)} and ${formatValue(right)}`,
|
|
575
586
|
);
|
|
576
587
|
}
|
|
577
|
-
return
|
|
588
|
+
return left.rank - right.rank;
|
|
578
589
|
};
|
|
579
590
|
|
|
580
591
|
const equalsModelValue = (left: ModelValue, right: Value) => {
|
|
@@ -723,16 +734,17 @@ const compareSetLikeTlc = (left: ObjectValue, right: Value): number => {
|
|
|
723
734
|
);
|
|
724
735
|
};
|
|
725
736
|
|
|
726
|
-
const compareLikeTlc = (left: Value, right: Value): number =>
|
|
727
|
-
|
|
728
|
-
if (typeof
|
|
729
|
-
|
|
730
|
-
|
|
731
|
-
|
|
732
|
-
|
|
733
|
-
|
|
734
|
-
|
|
735
|
-
|
|
737
|
+
const compareLikeTlc = (left: Value, right: Value): number =>
|
|
738
|
+
withSource(left, () => {
|
|
739
|
+
if (typeof left !== "object") {
|
|
740
|
+
if (typeof right === typeof left) return compareValues(left, right);
|
|
741
|
+
if (isModelValue(right)) return compareModelValueWith(right, left);
|
|
742
|
+
throw new TlaEvaluationError(describeScalarMismatch(left, right, false));
|
|
743
|
+
}
|
|
744
|
+
if (left.kind === "ModelValue") return compareModelValue(left, right);
|
|
745
|
+
if (isFunctionValue(left)) return compareFunctionLikeTlc(left, right);
|
|
746
|
+
return compareSetLikeTlc(left, right);
|
|
747
|
+
});
|
|
736
748
|
|
|
737
749
|
const equalsElementsLikeTlc = (left: Value[], right: Value[]) =>
|
|
738
750
|
left.every((element, index) => equalsLikeTlc(element, right[index]));
|
|
@@ -820,16 +832,17 @@ const equalsSetLikeTlc = (left: ObjectValue, right: Value): boolean => {
|
|
|
820
832
|
);
|
|
821
833
|
};
|
|
822
834
|
|
|
823
|
-
const equalsLikeTlc = (left: Value, right: Value): boolean =>
|
|
824
|
-
|
|
825
|
-
if (typeof
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
|
|
830
|
-
|
|
831
|
-
|
|
832
|
-
|
|
835
|
+
const equalsLikeTlc = (left: Value, right: Value): boolean =>
|
|
836
|
+
withSource(left, () => {
|
|
837
|
+
if (typeof left !== "object") {
|
|
838
|
+
if (typeof right === typeof left) return left === right;
|
|
839
|
+
if (isModelValue(right)) return equalsModelValueWith(right, left);
|
|
840
|
+
throw new TlaEvaluationError(describeScalarMismatch(left, right, true));
|
|
841
|
+
}
|
|
842
|
+
if (left.kind === "ModelValue") return equalsModelValue(left, right);
|
|
843
|
+
if (isFunctionValue(left)) return equalsFunctionLikeTlc(left, right);
|
|
844
|
+
return equalsSetLikeTlc(left, right);
|
|
845
|
+
});
|
|
833
846
|
|
|
834
847
|
// TLC's ValueVec.sort, which inserts each element into the sorted prefix by binary search.
|
|
835
848
|
const sortLikeTlc = (elements: Value[]) => {
|
|
@@ -861,9 +874,11 @@ export const isEqualLikeTlc = (left: Value, right: Value) => {
|
|
|
861
874
|
}
|
|
862
875
|
};
|
|
863
876
|
|
|
877
|
+
// TLC sorts a set by comparing each element with the ones before it, so the later element converts
|
|
878
|
+
// a lazy set it compares and caches it.
|
|
864
879
|
const isStrictlySorted = (elements: Value[]) => {
|
|
865
880
|
for (let index = 1; index < elements.length; index++) {
|
|
866
|
-
if (compareValues(elements[index
|
|
881
|
+
if (compareValues(elements[index], elements[index - 1]) <= 0) return false;
|
|
867
882
|
}
|
|
868
883
|
return true;
|
|
869
884
|
};
|
|
@@ -1066,13 +1081,16 @@ const isTlcEnumerable = (value: Value) => isSetValue(value) && !isOverriddenSet(
|
|
|
1066
1081
|
const formatUnion = (value: UnionValue, isStrict = false) =>
|
|
1067
1082
|
`UNION(${formatValue(value.base, isStrict)})`;
|
|
1068
1083
|
|
|
1069
|
-
const getUnionSets = (
|
|
1084
|
+
const getUnionSets = (
|
|
1085
|
+
value: UnionValue,
|
|
1086
|
+
getElements = (set: Value) => toFiniteSet(set).elements,
|
|
1087
|
+
) => {
|
|
1070
1088
|
if (!isTlcEnumerable(value.base)) {
|
|
1071
1089
|
throw new TlaEvaluationError(
|
|
1072
1090
|
`Attempted to enumerate the nonenumerable set:\n${formatUnion(value)}`,
|
|
1073
1091
|
);
|
|
1074
1092
|
}
|
|
1075
|
-
return
|
|
1093
|
+
return getElements(value.base);
|
|
1076
1094
|
};
|
|
1077
1095
|
|
|
1078
1096
|
const getUnionSet = (set: Value, index: number, union: UnionValue) => {
|
|
@@ -1108,7 +1126,7 @@ export const isEnumerable = (value: Value): boolean => {
|
|
|
1108
1126
|
case "ProductSet":
|
|
1109
1127
|
return value.factors.every(isEnumerable) || getEmptiness(value) === true;
|
|
1110
1128
|
case "Union":
|
|
1111
|
-
return isEnumerable(value.base) &&
|
|
1129
|
+
return isEnumerable(value.base) && getStreamedElements(value.base).every(isEnumerable);
|
|
1112
1130
|
case "SetOperation":
|
|
1113
1131
|
if (value.operator === "\\cup") return isEnumerable(value.left) && isEnumerable(value.right);
|
|
1114
1132
|
if (value.operator === "\\cap") return isEnumerable(value.left) || isEnumerable(value.right);
|
|
@@ -1209,9 +1227,7 @@ const enumerateSet = (value: Value): Value[] => {
|
|
|
1209
1227
|
if (isOverriddenSet(value.base)) getCardinality(value.base);
|
|
1210
1228
|
const base = toFiniteSet(value.base).elements;
|
|
1211
1229
|
if (base.length > MAXIMUM_ENUMERATED_SUBSET_BASE) {
|
|
1212
|
-
throw new TlaEvaluationError(
|
|
1213
|
-
`SUBSET of a set with ${base.length} elements is too large to enumerate`,
|
|
1214
|
-
);
|
|
1230
|
+
throw new TlaEvaluationError(describeOverflow(value));
|
|
1215
1231
|
}
|
|
1216
1232
|
return getSortedSubsets(base);
|
|
1217
1233
|
}
|
|
@@ -1315,6 +1331,7 @@ const enumerateSet = (value: Value): Value[] => {
|
|
|
1315
1331
|
};
|
|
1316
1332
|
|
|
1317
1333
|
const finiteSets = new WeakMap<ObjectValue, SetValue>();
|
|
1334
|
+
const comparedSets = new WeakMap<ObjectValue, SetValue>();
|
|
1318
1335
|
|
|
1319
1336
|
export const toFiniteSet = (value: Value): SetValue => {
|
|
1320
1337
|
if (typeof value === "object" && value.kind === "Set") return value;
|
|
@@ -1323,6 +1340,16 @@ export const toFiniteSet = (value: Value): SetValue => {
|
|
|
1323
1340
|
}
|
|
1324
1341
|
const cached = typeof value === "object" ? finiteSets.get(value) : undefined;
|
|
1325
1342
|
if (cached) return cached;
|
|
1343
|
+
const set =
|
|
1344
|
+
(typeof value === "object" ? comparedSets.get(value) : undefined) ??
|
|
1345
|
+
(valueSources.current
|
|
1346
|
+
? withSource(value, () => enumerateFiniteSet(value))
|
|
1347
|
+
: enumerateFiniteSet(value));
|
|
1348
|
+
if (typeof value === "object") finiteSets.set(value, set);
|
|
1349
|
+
return set;
|
|
1350
|
+
};
|
|
1351
|
+
|
|
1352
|
+
const enumerateFiniteSet = (value: Value) => {
|
|
1326
1353
|
const elements = enumerateSet(value);
|
|
1327
1354
|
const isSorted =
|
|
1328
1355
|
typeof value === "object" &&
|
|
@@ -1333,8 +1360,20 @@ export const toFiniteSet = (value: Value): SetValue => {
|
|
|
1333
1360
|
value.kind === "ProductSet" ||
|
|
1334
1361
|
value.kind === "FunctionSet" ||
|
|
1335
1362
|
value.kind === "Subset");
|
|
1336
|
-
|
|
1337
|
-
|
|
1363
|
+
return isSorted ? createSortedSet(elements) : createSet(elements);
|
|
1364
|
+
};
|
|
1365
|
+
|
|
1366
|
+
// TLC converts the set a comparison receives as its argument without caching it, so a lazy set
|
|
1367
|
+
// compared that way still streams the sets it combines.
|
|
1368
|
+
const toComparedSet = (value: Value) => {
|
|
1369
|
+
const isStreamed =
|
|
1370
|
+
typeof value === "object" &&
|
|
1371
|
+
(value.kind === "Union" || value.kind === "SetOperation" || value.kind === "FilteredSet");
|
|
1372
|
+
if (!isStreamed || finiteSets.has(value)) return toFiniteSet(value);
|
|
1373
|
+
const compared = comparedSets.get(value);
|
|
1374
|
+
if (compared) return compared;
|
|
1375
|
+
const set = enumerateFiniteSet(value);
|
|
1376
|
+
comparedSets.set(value, set);
|
|
1338
1377
|
return set;
|
|
1339
1378
|
};
|
|
1340
1379
|
|
|
@@ -1342,8 +1381,10 @@ export const toFiniteSet = (value: Value): SetValue => {
|
|
|
1342
1381
|
// so an element that two of them share comes up once for each.
|
|
1343
1382
|
export const getStreamedElements = (value: Value): Value[] => {
|
|
1344
1383
|
if (typeof value !== "object" || finiteSets.has(value)) return toFiniteSet(value).elements;
|
|
1384
|
+
// TLC streams the sets of a UNION it hasn't enumerated, so a set that appears twice there yields
|
|
1385
|
+
// its elements twice.
|
|
1345
1386
|
if (value.kind === "Union") {
|
|
1346
|
-
return getUnionSets(value).flatMap((set, index) =>
|
|
1387
|
+
return getUnionSets(value, getStreamedElements).flatMap((set, index) =>
|
|
1347
1388
|
getStreamedElements(getUnionSet(set, index, value)),
|
|
1348
1389
|
);
|
|
1349
1390
|
}
|
|
@@ -1562,6 +1603,12 @@ const describeNonSetMembership = (element: Value, value: Value) => {
|
|
|
1562
1603
|
return `${prefix} function ${formatValue(value)}`;
|
|
1563
1604
|
};
|
|
1564
1605
|
|
|
1606
|
+
// TLC checks membership in a set that another set holds through the inner set's own method.
|
|
1607
|
+
const isElementOfSet = (element: Value, set: Value) =>
|
|
1608
|
+
valueSources.current
|
|
1609
|
+
? withSource(set, () => isElementOf(element, set))
|
|
1610
|
+
: isElementOf(element, set);
|
|
1611
|
+
|
|
1565
1612
|
export const isElementOf = (element: Value, set: Value): boolean => {
|
|
1566
1613
|
if (!isSetValue(set)) throw new TlaEvaluationError(describeNonSetMembership(element, set));
|
|
1567
1614
|
switch (set.kind) {
|
|
@@ -1570,10 +1617,10 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1570
1617
|
return findIndex(set.elements, element) !== -1;
|
|
1571
1618
|
} catch (error) {
|
|
1572
1619
|
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
1573
|
-
return isElementOfLikeTlc(element, set.elements);
|
|
1620
|
+
return withSource(set, () => isElementOfLikeTlc(element, set.elements));
|
|
1574
1621
|
}
|
|
1575
1622
|
case "MixedSet":
|
|
1576
|
-
return isElementOfLikeTlc(element, set.elements);
|
|
1623
|
+
return withSource(set, () => isElementOfLikeTlc(element, set.elements));
|
|
1577
1624
|
case "Interval":
|
|
1578
1625
|
if (typeof element === "number") return element >= set.low && element <= set.high;
|
|
1579
1626
|
if (set.low <= set.high && !isModelValue(element)) {
|
|
@@ -1595,12 +1642,18 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1595
1642
|
return set.name !== "Nat" || (typeof element === "number" && element >= 0);
|
|
1596
1643
|
}
|
|
1597
1644
|
case "Subset":
|
|
1598
|
-
if (!
|
|
1599
|
-
|
|
1645
|
+
if (!isTlcEnumerable(element)) {
|
|
1646
|
+
throw new TlaEvaluationError(
|
|
1647
|
+
`Attempted to check if the non-enumerable value\n${prettyPrint(formatValue(element))}\nis element of\n${prettyPrint(formatValue(set))}`,
|
|
1648
|
+
);
|
|
1649
|
+
}
|
|
1650
|
+
return toFiniteSet(element).elements.every((item) => isElementOfSet(item, set.base));
|
|
1600
1651
|
case "FunctionSet": {
|
|
1601
1652
|
if (!isFunctionValue(element)) {
|
|
1602
1653
|
if (isModelValue(element)) return false;
|
|
1603
|
-
throw new TlaEvaluationError(
|
|
1654
|
+
throw new TlaEvaluationError(
|
|
1655
|
+
`Attempted to check if \n${formatValue(element)}\nwhich is not a TLC function value, is in the set of functions:\n${prettyPrint(formatValue(set))}`,
|
|
1656
|
+
);
|
|
1604
1657
|
}
|
|
1605
1658
|
const functionValue = toFiniteFunction(element);
|
|
1606
1659
|
const low = getIntervalLow(functionValue.domain);
|
|
@@ -1611,7 +1664,7 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1611
1664
|
{ kind: "Interval", low, high: low + functionValue.domain.length - 1 },
|
|
1612
1665
|
set.domain,
|
|
1613
1666
|
);
|
|
1614
|
-
return isDomain && functionValue.range.every((item) =>
|
|
1667
|
+
return isDomain && functionValue.range.every((item) => isElementOfSet(item, set.range));
|
|
1615
1668
|
}
|
|
1616
1669
|
case "RecordSet": {
|
|
1617
1670
|
const functionValue = isFunctionValue(element) ? toFiniteFunction(element) : undefined;
|
|
@@ -1625,7 +1678,7 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1625
1678
|
functionValue.domain.length === set.names.length &&
|
|
1626
1679
|
set.names.every((name, index) => {
|
|
1627
1680
|
const position = findIndex(functionValue.domain, name);
|
|
1628
|
-
return position !== -1 &&
|
|
1681
|
+
return position !== -1 && isElementOfSet(functionValue.range[position], set.sets[index]);
|
|
1629
1682
|
})
|
|
1630
1683
|
);
|
|
1631
1684
|
}
|
|
@@ -1642,24 +1695,24 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1642
1695
|
}
|
|
1643
1696
|
return (
|
|
1644
1697
|
elements.length === set.factors.length &&
|
|
1645
|
-
elements.every((item, index) =>
|
|
1698
|
+
elements.every((item, index) => isElementOfSet(item, set.factors[index]))
|
|
1646
1699
|
);
|
|
1647
1700
|
}
|
|
1648
1701
|
case "FilteredSet":
|
|
1649
|
-
return
|
|
1702
|
+
return isElementOfSet(element, set.base) && set.test(element);
|
|
1650
1703
|
case "Union":
|
|
1651
1704
|
if (!isTlcEnumerable(set.base)) {
|
|
1652
1705
|
throw new TlaEvaluationError(
|
|
1653
1706
|
`Attempted to check if:\n ${formatValue(element)}\nis an element of the non-enumerable set:\n ${formatUnion(set)}`,
|
|
1654
1707
|
);
|
|
1655
1708
|
}
|
|
1656
|
-
return toFiniteSet(set.base).elements.some((inner) =>
|
|
1709
|
+
return toFiniteSet(set.base).elements.some((inner) => isElementOfSet(element, inner));
|
|
1657
1710
|
case "SetOperation":
|
|
1658
1711
|
if (set.operator === "\\cup")
|
|
1659
|
-
return
|
|
1712
|
+
return isElementOfSet(element, set.left) || isElementOfSet(element, set.right);
|
|
1660
1713
|
return (
|
|
1661
|
-
|
|
1662
|
-
|
|
1714
|
+
isElementOfSet(element, set.left) &&
|
|
1715
|
+
isElementOfSet(element, set.right) === (set.operator === "\\cap")
|
|
1663
1716
|
);
|
|
1664
1717
|
case "SequenceSet": {
|
|
1665
1718
|
const elements = getSequenceElements(element);
|
|
@@ -1715,10 +1768,61 @@ export const markLambdaFunction = <FunctionLike extends FunctionValue | LazyFunc
|
|
|
1715
1768
|
return functionValue;
|
|
1716
1769
|
};
|
|
1717
1770
|
|
|
1718
|
-
|
|
1719
|
-
|
|
1720
|
-
|
|
1721
|
-
|
|
1771
|
+
// TLC applies a tuple, a record and a function over an interval with their own classes, and each
|
|
1772
|
+
// reports a missing argument in its own words.
|
|
1773
|
+
const getFunctionClass = (functionValue: FunctionValue) => {
|
|
1774
|
+
const domain = functionValue.domain;
|
|
1775
|
+
if (domain.length === 0) return lambdaFunctions.has(functionValue) ? "FcnRcdValue" : "TupleValue";
|
|
1776
|
+
if (domain === intervalDomains[domain.length]) return "TupleValue";
|
|
1777
|
+
if (intervalArrays.has(domain)) return "IntervalFcnRcdValue";
|
|
1778
|
+
return domain.every((key) => typeof key === "string") ? "RecordValue" : "FcnRcdValue";
|
|
1779
|
+
};
|
|
1780
|
+
|
|
1781
|
+
const describeNotInDomain = (functionValue: FunctionValue, argument: Value) =>
|
|
1782
|
+
`Attempted to apply function:\n${prettyPrint(formatValue(functionValue))}\nto argument ${prettyPrint(formatValue(argument))}, which is not in the domain of the function.`;
|
|
1783
|
+
|
|
1784
|
+
const describeNonIntegerArgument = (argument: Value) =>
|
|
1785
|
+
`Attempted to apply function with integer domain to the non-integer argument ${prettyPrint(formatValue(argument))}`;
|
|
1786
|
+
|
|
1787
|
+
const describeMissingArgument = (
|
|
1788
|
+
functionValue: FunctionValue | LazyFunctionValue,
|
|
1789
|
+
argument: Value,
|
|
1790
|
+
) => {
|
|
1791
|
+
if (lambdaFunctions.has(functionValue) || functionValue.kind === "LazyFunction")
|
|
1792
|
+
return `In applying the function\n${prettyPrint(formatValue(functionValue))},\nthe first argument is:\n${prettyPrint(formatValue(argument))}\nwhich is not in its domain.\n`;
|
|
1793
|
+
const functionClass = getFunctionClass(functionValue);
|
|
1794
|
+
if (functionClass === "TupleValue")
|
|
1795
|
+
return typeof argument === "number"
|
|
1796
|
+
? `Attempted to access index ${argument} of tuple\n${prettyPrint(formatValue(functionValue))}\nwhich is out of bounds.`
|
|
1797
|
+
: `Attempted to access tuple at a non integral index: ${prettyPrint(formatValue(argument))}`;
|
|
1798
|
+
if (functionClass === "RecordValue")
|
|
1799
|
+
return typeof argument === "string"
|
|
1800
|
+
? `Attempted to access nonexistent field '${argument}' of record\n${prettyPrint(formatValue(functionValue))}`
|
|
1801
|
+
: `Attempted to access record by a non-string argument: ${prettyPrint(formatValue(argument))}`;
|
|
1802
|
+
return functionClass === "IntervalFcnRcdValue" && typeof argument !== "number"
|
|
1803
|
+
? describeNonIntegerArgument(argument)
|
|
1804
|
+
: describeNotInDomain(functionValue, argument);
|
|
1805
|
+
};
|
|
1806
|
+
|
|
1807
|
+
// TLC selects a field of a value that isn't a record from the function the value converts to,
|
|
1808
|
+
// which keeps a tuple's domain as an interval.
|
|
1809
|
+
export const describeMissingField = (functionValue: FunctionValue, field: string) =>
|
|
1810
|
+
getFunctionClass(functionValue) === "FcnRcdValue"
|
|
1811
|
+
? describeNotInDomain(functionValue, field)
|
|
1812
|
+
: describeNonIntegerArgument(field);
|
|
1813
|
+
|
|
1814
|
+
export const isRecordValue = (functionValue: FunctionValue) =>
|
|
1815
|
+
getFunctionClass(functionValue) === "RecordValue";
|
|
1816
|
+
|
|
1817
|
+
// TLC checks the type of an argument to a tuple or a record before it looks the argument up, so
|
|
1818
|
+
// it never compares the argument with a key of another type.
|
|
1819
|
+
const isForeignKey = (domain: Value[], argument: Value) => {
|
|
1820
|
+
const first = domain[0];
|
|
1821
|
+
return typeof first === "number"
|
|
1822
|
+
? typeof argument !== "number" &&
|
|
1823
|
+
(domain === intervalDomains[domain.length] || intervalArrays.has(domain))
|
|
1824
|
+
: typeof first === "string" && typeof argument !== "string";
|
|
1825
|
+
};
|
|
1722
1826
|
|
|
1723
1827
|
const findKeyIndex = (domain: Value[], argument: Value) => {
|
|
1724
1828
|
const first = domain[0];
|
|
@@ -1737,6 +1841,7 @@ export const applyFunction = (
|
|
|
1737
1841
|
functionValue: Value,
|
|
1738
1842
|
argument: Value,
|
|
1739
1843
|
describeMissing?: (functionValue: FunctionValue) => string,
|
|
1844
|
+
describeNonFunction?: (value: Value) => string,
|
|
1740
1845
|
): Value => {
|
|
1741
1846
|
if (typeof functionValue === "object" && functionValue.kind === "LazyFunction") {
|
|
1742
1847
|
if (!isElementOf(argument, functionValue.domain)) {
|
|
@@ -1750,10 +1855,13 @@ export const applyFunction = (
|
|
|
1750
1855
|
}
|
|
1751
1856
|
if (typeof functionValue !== "object" || functionValue.kind !== "Function") {
|
|
1752
1857
|
throw new TlaEvaluationError(
|
|
1753
|
-
|
|
1858
|
+
describeNonFunction?.(functionValue) ??
|
|
1859
|
+
`Attempted to apply ${formatValue(functionValue)}, which is not a function`,
|
|
1754
1860
|
);
|
|
1755
1861
|
}
|
|
1756
|
-
const position =
|
|
1862
|
+
const position = isForeignKey(functionValue.domain, argument)
|
|
1863
|
+
? -1
|
|
1864
|
+
: findKeyIndex(functionValue.domain, argument);
|
|
1757
1865
|
if (position === -1) {
|
|
1758
1866
|
throw new TlaEvaluationError(
|
|
1759
1867
|
describeMissing?.(functionValue) ?? describeMissingArgument(functionValue, argument),
|
|
@@ -2098,8 +2206,11 @@ export const formatValue = (value: Value, isStrict = false, isNormalized = false
|
|
|
2098
2206
|
return `[${parameters} |-> <expression ${source.body}>]`;
|
|
2099
2207
|
}
|
|
2100
2208
|
const functionValue = toFiniteFunction(value);
|
|
2209
|
+
// TLC normalizes a lambda's domain to print it, but evaluates its body afterward.
|
|
2210
|
+
const formatRange = (inner: Value) =>
|
|
2211
|
+
formatValue(inner, isStrict, isNormalized && value.kind === "Function");
|
|
2101
2212
|
if (functionValue.domain.every((key, index) => key === index + 1)) {
|
|
2102
|
-
return `<<${functionValue.range.map(
|
|
2213
|
+
return `<<${functionValue.range.map(formatRange).join(", ")}>>`;
|
|
2103
2214
|
}
|
|
2104
2215
|
if (functionValue.domain.every((key) => typeof key === "string" && isFieldName(key))) {
|
|
2105
2216
|
const isSorted =
|
|
@@ -2107,9 +2218,20 @@ export const formatValue = (value: Value, isStrict = false, isNormalized = false
|
|
|
2107
2218
|
const pairs = isSorted
|
|
2108
2219
|
? functionValue.domain.map((key, index) => [key, functionValue.range[index]])
|
|
2109
2220
|
: getWrittenPairs(functionValue);
|
|
2110
|
-
return `[${pairs.map((pair) => `${String(pair[0])} |-> ${
|
|
2221
|
+
return `[${pairs.map((pair) => `${String(pair[0])} |-> ${formatRange(pair[1])}`).join(", ")}]`;
|
|
2111
2222
|
}
|
|
2112
|
-
return `(${functionValue.domain.map((key, index) => `${format(key)} :> ${
|
|
2223
|
+
return `(${functionValue.domain.map((key, index) => `${format(key)} :> ${formatRange(functionValue.range[index])}`).join(" @@ ")})`;
|
|
2113
2224
|
}
|
|
2114
2225
|
}
|
|
2115
2226
|
};
|
|
2227
|
+
|
|
2228
|
+
// TLC's TLCState.toString: a line per variable, as a conjunction when there are several.
|
|
2229
|
+
export const formatState = (state: Record<string, Value>) => {
|
|
2230
|
+
const entries = Object.entries(state);
|
|
2231
|
+
return entries
|
|
2232
|
+
.map(
|
|
2233
|
+
([name, value]) =>
|
|
2234
|
+
`${entries.length === 1 ? "" : "/\\ "}${name} = ${prettyPrint(formatValue(value))}\n`,
|
|
2235
|
+
)
|
|
2236
|
+
.join("");
|
|
2237
|
+
};
|