tla-ts 0.0.4-dev.4819fb7 → 0.0.4-dev.5c7c024
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/dist/run-cli.cjs +1 -1
- package/dist/run-cli.js +1 -1
- package/dist/transfer.cjs +27 -27
- package/dist/transfer.js +27 -27
- package/package.json +1 -1
- package/src/check.ts +1 -0
- package/src/codegen.ts +26 -7
- package/src/evaluate.ts +25 -11
- package/src/standard-modules.ts +5 -2
- package/src/tlc-random.ts +55 -32
- package/src/values.ts +65 -31
package/package.json
CHANGED
package/src/check.ts
CHANGED
package/src/codegen.ts
CHANGED
|
@@ -177,7 +177,7 @@ const generateQuantifier = (
|
|
|
177
177
|
}, test);
|
|
178
178
|
const parameters = outer.map((local) => `, ${local}`).join("");
|
|
179
179
|
generator.helpers.push(
|
|
180
|
-
`function ${name}(context, state, next${parameters}) { let primed; ${declarations.join(" ")} ${loops} return ${isForall}; }`,
|
|
180
|
+
`function ${name}(context, state, next${parameters}) { let primed; let applied; ${declarations.join(" ")} ${loops} return ${isForall}; }`,
|
|
181
181
|
);
|
|
182
182
|
return `${name}(${frame.context}, ${frame.state}, ${frame.isPrimed ? "undefined" : frame.next}${parameters})`;
|
|
183
183
|
};
|
|
@@ -247,6 +247,23 @@ const isConstructionFree = (
|
|
|
247
247
|
}
|
|
248
248
|
};
|
|
249
249
|
|
|
250
|
+
// Whether the generated code evaluates an expression only in the context its frame names. A primed
|
|
251
|
+
// expression doesn't, since it shares the generated function's primed context.
|
|
252
|
+
const isReadOnly = (expression: Expression): boolean => {
|
|
253
|
+
switch (expression.kind) {
|
|
254
|
+
case "Identifier":
|
|
255
|
+
case "Number":
|
|
256
|
+
case "String":
|
|
257
|
+
return true;
|
|
258
|
+
case "FieldAccess":
|
|
259
|
+
return isReadOnly(expression.record);
|
|
260
|
+
case "FunctionApplication":
|
|
261
|
+
return [expression.function, ...expression.args].every(isReadOnly);
|
|
262
|
+
default:
|
|
263
|
+
return false;
|
|
264
|
+
}
|
|
265
|
+
};
|
|
266
|
+
|
|
250
267
|
const generateExpression = (generator: Generator, expression: Expression, frame: Frame): string => {
|
|
251
268
|
const generate = (node: Expression, nodeFrame = frame) =>
|
|
252
269
|
generateExpression(generator, node, nodeFrame);
|
|
@@ -287,17 +304,19 @@ const generateExpression = (generator: Generator, expression: Expression, frame:
|
|
|
287
304
|
case "FunctionApplication": {
|
|
288
305
|
keepLazy(expression.function);
|
|
289
306
|
// The interpreter evaluates a function that may construct one with EvalControl.KeepLazy.
|
|
307
|
+
const keepLazyFrame = { ...frame, context: `keepLazyContext(${frame.context})` };
|
|
290
308
|
const evaluatedFunction = isConstructionFree(
|
|
291
309
|
expression.function,
|
|
292
310
|
frame,
|
|
293
311
|
generator.environment,
|
|
294
312
|
)
|
|
295
313
|
? generate(expression.function)
|
|
296
|
-
:
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
314
|
+
: isReadOnly(expression.function)
|
|
315
|
+
? generate(expression.function, keepLazyFrame)
|
|
316
|
+
: generateDelegate(generator, expression.function, keepLazyFrame);
|
|
317
|
+
// Tool#evalAppl checks that it applies a function before it evaluates the argument. The check
|
|
318
|
+
// is written out, as calling expectFunction for each application costs more.
|
|
319
|
+
const functionCode = `(applied = ${evaluatedFunction}, typeof applied === "object" && (applied.kind === "Function" || applied.kind === "LazyFunction") ? applied : expectFunction(applied, ${addReference(generator, expression)}))`;
|
|
301
320
|
const describeMissing = getMissingArgumentDescriber(generator.environment.runtime.version);
|
|
302
321
|
const error = describeMissing ? `, ${addReference(generator, describeMissing)}` : "";
|
|
303
322
|
if (expression.args.length === 1)
|
|
@@ -370,7 +389,7 @@ export const generateEvaluator = (
|
|
|
370
389
|
};
|
|
371
390
|
const body = generateExpression(generator, expression, frame);
|
|
372
391
|
const referenceNames = generator.references.map((_, index) => `reference${index}`);
|
|
373
|
-
const source = `${generator.helpers.join("\n")}\nreturn (context) => { const state = context.state; const next = context.next; let primed; return ${body}; };`;
|
|
392
|
+
const source = `${generator.helpers.join("\n")}\nreturn (context) => { const state = context.state; const next = context.next; let primed; let applied; return ${body}; };`;
|
|
374
393
|
runtime.value ??= createRuntime();
|
|
375
394
|
const helpers = runtime.value;
|
|
376
395
|
const helperNames = Object.keys(helpers);
|
package/src/evaluate.ts
CHANGED
|
@@ -54,6 +54,7 @@ import {
|
|
|
54
54
|
markLambdaFunction,
|
|
55
55
|
isReducibleSet,
|
|
56
56
|
isSetValue,
|
|
57
|
+
isSettledValue,
|
|
57
58
|
MAXIMUM_INTEGER,
|
|
58
59
|
MINIMUM_INTEGER,
|
|
59
60
|
toFiniteFunction,
|
|
@@ -113,6 +114,9 @@ export interface Thunk {
|
|
|
113
114
|
state: State | undefined;
|
|
114
115
|
next: State | undefined;
|
|
115
116
|
cache: Value | undefined;
|
|
117
|
+
// Whether the expression may build a set that streams until TLC caches it, so that the thunk
|
|
118
|
+
// caches only a settled value.
|
|
119
|
+
isStreamed: boolean;
|
|
116
120
|
}
|
|
117
121
|
|
|
118
122
|
type Binding = { kind: "Value"; value: Value } | Thunk | { kind: "Operator"; operator: Operator };
|
|
@@ -847,7 +851,7 @@ const forceThunk = (thunk: Thunk, context: Context) => {
|
|
|
847
851
|
const isSameState = thunk.state === context.state && thunk.next === context.next;
|
|
848
852
|
if (isSameState && thunk.cache !== undefined) return thunk.cache;
|
|
849
853
|
const value = evaluate(thunk.expression, withScope(context, thunk.scope));
|
|
850
|
-
if (isSameState) thunk.cache = value;
|
|
854
|
+
if (isSameState && (!thunk.isStreamed || isSettledValue(value))) thunk.cache = value;
|
|
851
855
|
return value;
|
|
852
856
|
};
|
|
853
857
|
|
|
@@ -968,6 +972,7 @@ const createThunk = (expression: Expression, context: Context): Thunk => ({
|
|
|
968
972
|
state: context.state,
|
|
969
973
|
next: context.next,
|
|
970
974
|
cache: undefined,
|
|
975
|
+
isStreamed: false,
|
|
971
976
|
});
|
|
972
977
|
|
|
973
978
|
export const findGlobalName = (name: string, environment: Environment): GlobalName | undefined => {
|
|
@@ -1064,10 +1069,16 @@ const callOperator = (operator: Operator, args: Expression[], context: Context)
|
|
|
1064
1069
|
);
|
|
1065
1070
|
};
|
|
1066
1071
|
|
|
1072
|
+
// The LET definitions that a reference evaluates again, and those that cache only a settled value.
|
|
1073
|
+
interface ReevaluatedDefinitions {
|
|
1074
|
+
impure: ReadonlySet<Definition>;
|
|
1075
|
+
streamed: ReadonlySet<Definition>;
|
|
1076
|
+
}
|
|
1077
|
+
|
|
1067
1078
|
export const bindDefinitions = (
|
|
1068
1079
|
definitions: Definition[],
|
|
1069
1080
|
context: Context,
|
|
1070
|
-
reevaluated?:
|
|
1081
|
+
reevaluated?: ReevaluatedDefinitions,
|
|
1071
1082
|
): Scope | undefined =>
|
|
1072
1083
|
definitions.reduce<Scope | undefined>((scope, definition) => {
|
|
1073
1084
|
const node: Scope = {
|
|
@@ -1089,10 +1100,11 @@ export const bindDefinitions = (
|
|
|
1089
1100
|
state: context.state,
|
|
1090
1101
|
next: context.next,
|
|
1091
1102
|
cache: undefined,
|
|
1103
|
+
isStreamed: false,
|
|
1092
1104
|
};
|
|
1093
1105
|
return node;
|
|
1094
1106
|
}
|
|
1095
|
-
if (definition.params.length > 0 || reevaluated?.has(definition)) {
|
|
1107
|
+
if (definition.params.length > 0 || reevaluated?.impure.has(definition)) {
|
|
1096
1108
|
node.binding = {
|
|
1097
1109
|
kind: "Operator",
|
|
1098
1110
|
operator: {
|
|
@@ -1112,6 +1124,7 @@ export const bindDefinitions = (
|
|
|
1112
1124
|
state: context.state,
|
|
1113
1125
|
next: context.next,
|
|
1114
1126
|
cache: undefined,
|
|
1127
|
+
isStreamed: reevaluated?.streamed.has(definition) ?? false,
|
|
1115
1128
|
};
|
|
1116
1129
|
return node;
|
|
1117
1130
|
}, context.scope);
|
|
@@ -1228,14 +1241,15 @@ const STREAMED_SET: Impurity = {
|
|
|
1228
1241
|
// TLC's next-state generator does not bind LET definitions to values, so each reference to one
|
|
1229
1242
|
// evaluates it again: one that calls an impure builtin repeats its effects, and a set one builds
|
|
1230
1243
|
// with UNION or \cup starts out uncached.
|
|
1231
|
-
export const getReevaluatedDefinitions = (
|
|
1232
|
-
|
|
1233
|
-
|
|
1234
|
-
|
|
1235
|
-
|
|
1236
|
-
|
|
1237
|
-
),
|
|
1238
|
-
)
|
|
1244
|
+
export const getReevaluatedDefinitions = (
|
|
1245
|
+
definitions: Definition[],
|
|
1246
|
+
environment: Environment,
|
|
1247
|
+
): ReevaluatedDefinitions => ({
|
|
1248
|
+
impure: new Set(definitions.filter((definition) => isImpureDefinition(definition, environment))),
|
|
1249
|
+
streamed: new Set(
|
|
1250
|
+
definitions.filter((definition) => isImpureDefinition(definition, environment, STREAMED_SET)),
|
|
1251
|
+
),
|
|
1252
|
+
});
|
|
1239
1253
|
|
|
1240
1254
|
export const isImpure = (environment: Environment) =>
|
|
1241
1255
|
[...environment.definitions.values()].some((definition) =>
|
package/src/standard-modules.ts
CHANGED
|
@@ -162,8 +162,11 @@ export const CORE_OPERATORS: Builtin[] = [
|
|
|
162
162
|
: differenceSorted;
|
|
163
163
|
// The merge compares the elements, which TLC tests for membership one by one instead.
|
|
164
164
|
return computeLikeTlcOnFailure(
|
|
165
|
-
() => merge(toFiniteSet(
|
|
166
|
-
() =>
|
|
165
|
+
(finiteLeft, finiteRight) => merge(toFiniteSet(finiteLeft), toFiniteSet(finiteRight)),
|
|
166
|
+
(reducibleLeft, reducibleRight) =>
|
|
167
|
+
combineReducible(operator, reducibleLeft, reducibleRight),
|
|
168
|
+
left,
|
|
169
|
+
right,
|
|
167
170
|
);
|
|
168
171
|
}
|
|
169
172
|
if (isReducibleSet(left)) return combineReducible(operator, left, right);
|
package/src/tlc-random.ts
CHANGED
|
@@ -182,24 +182,14 @@ const createShiftTable = (length: number) => {
|
|
|
182
182
|
|
|
183
183
|
// Extending a fingerprint by a byte is linear over GF(2), so extending it by a value's bytes
|
|
184
184
|
// XORs the value's own fingerprint from zero into the fingerprint shifted by their length.
|
|
185
|
-
// The fingerprinter caches each distinct
|
|
186
|
-
//
|
|
187
|
-
// `words`, an Int32Array over a
|
|
185
|
+
// The fingerprinter caches each distinct function or set it meets, nested ones included, for one
|
|
186
|
+
// pass over the stored states, as states share most of their values. It reads a state's variables
|
|
187
|
+
// in `order` and writes each fingerprint's low and high words into `words`, an Int32Array over a
|
|
188
|
+
// little-endian BigInt64Array.
|
|
188
189
|
export const createTlcFingerprinter = (order: number[], words: Int32Array) => {
|
|
189
190
|
const shiftTables = new Map<number, Int32Array>();
|
|
190
191
|
const indices = new Map<Value, number>();
|
|
191
192
|
const contributions: number[] = [];
|
|
192
|
-
const getContribution = (value: Value) => {
|
|
193
|
-
const cached = indices.get(value);
|
|
194
|
-
if (cached !== undefined) return cached;
|
|
195
|
-
const length = getFingerprintLength(value);
|
|
196
|
-
high = 0;
|
|
197
|
-
low = 0;
|
|
198
|
-
extendValue(value);
|
|
199
|
-
indices.set(value, contributions.length);
|
|
200
|
-
contributions.push(length, high, low);
|
|
201
|
-
return contributions.length - 3;
|
|
202
|
-
};
|
|
203
193
|
const getShiftTable = (length: number) => {
|
|
204
194
|
const cached = shiftTables.get(length);
|
|
205
195
|
if (cached) return cached;
|
|
@@ -207,29 +197,62 @@ export const createTlcFingerprinter = (order: number[], words: Int32Array) => {
|
|
|
207
197
|
shiftTables.set(length, table);
|
|
208
198
|
return table;
|
|
209
199
|
};
|
|
210
|
-
|
|
200
|
+
// Extends the fingerprint by a value's bytes and returns how many there are.
|
|
201
|
+
const extendElement = (value: Value): number => {
|
|
202
|
+
if (typeof value !== "object" || isModelValue(value)) {
|
|
203
|
+
extendValue(value);
|
|
204
|
+
return getFingerprintLength(value);
|
|
205
|
+
}
|
|
206
|
+
const contribution = getContribution(value);
|
|
207
|
+
const shifted = { high, low };
|
|
208
|
+
const table = getShiftTable(contributions[contribution]);
|
|
209
|
+
high = contributions[contribution + 1];
|
|
210
|
+
low = contributions[contribution + 2];
|
|
211
|
+
for (let position = 0; position < 8; position++) {
|
|
212
|
+
const word = position < 4 ? shifted.low : shifted.high;
|
|
213
|
+
const entry = (position * 256 + ((word >>> ((position & 3) * 8)) & 0xff)) * 2;
|
|
214
|
+
high ^= table[entry];
|
|
215
|
+
low ^= table[entry + 1];
|
|
216
|
+
}
|
|
217
|
+
return contributions[contribution];
|
|
218
|
+
};
|
|
219
|
+
const getContribution = (value: Value) => {
|
|
220
|
+
const cached = indices.get(value);
|
|
221
|
+
if (cached !== undefined) return cached;
|
|
211
222
|
const outer = { high, low };
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
const
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
const entry = (position * 256 + ((word >>> ((position & 3) * 8)) & 0xff)) * 2;
|
|
223
|
-
extended.high ^= table[entry];
|
|
224
|
-
extended.low ^= table[entry + 1];
|
|
223
|
+
high = 0;
|
|
224
|
+
low = 0;
|
|
225
|
+
const length = { value: 5 };
|
|
226
|
+
if (isFunctionValue(value)) {
|
|
227
|
+
const functionValue = toFiniteFunction(value);
|
|
228
|
+
extendByte(FCN_RCD_VALUE);
|
|
229
|
+
extendInt(functionValue.domain.length);
|
|
230
|
+
for (let index = 0; index < functionValue.domain.length; index++) {
|
|
231
|
+
length.value += extendElement(functionValue.domain[index]);
|
|
232
|
+
length.value += extendElement(functionValue.range[index]);
|
|
225
233
|
}
|
|
226
|
-
|
|
227
|
-
|
|
234
|
+
} else {
|
|
235
|
+
const elements = toFiniteSet(value).elements;
|
|
236
|
+
extendByte(SET_ENUM_VALUE);
|
|
237
|
+
extendInt(elements.length);
|
|
238
|
+
for (const element of elements) length.value += extendElement(element);
|
|
228
239
|
}
|
|
240
|
+
const contribution = contributions.length;
|
|
241
|
+
indices.set(value, contribution);
|
|
242
|
+
contributions.push(length.value, high, low);
|
|
243
|
+
high = outer.high;
|
|
244
|
+
low = outer.low;
|
|
245
|
+
return contribution;
|
|
246
|
+
};
|
|
247
|
+
return (state: Value[], position: number) => {
|
|
248
|
+
const outer = { high, low };
|
|
249
|
+
high = INITIAL_HIGH;
|
|
250
|
+
low = INITIAL_LOW;
|
|
251
|
+
for (const index of order) extendElement(state[index]);
|
|
252
|
+
words[2 * position] = low;
|
|
253
|
+
words[2 * position + 1] = high;
|
|
229
254
|
high = outer.high;
|
|
230
255
|
low = outer.low;
|
|
231
|
-
words[2 * position] = fingerprint.low;
|
|
232
|
-
words[2 * position + 1] = fingerprint.high;
|
|
233
256
|
};
|
|
234
257
|
};
|
|
235
258
|
|
package/src/values.ts
CHANGED
|
@@ -1025,10 +1025,7 @@ export const markNormalized = (value: Value): void => {
|
|
|
1025
1025
|
};
|
|
1026
1026
|
|
|
1027
1027
|
export const isEqualLikeTlc = (left: Value, right: Value) =>
|
|
1028
|
-
computeLikeTlcOnFailure(
|
|
1029
|
-
() => valuesEqual(left, right),
|
|
1030
|
-
() => equalsLikeTlc(left, right),
|
|
1031
|
-
);
|
|
1028
|
+
computeLikeTlcOnFailure(valuesEqual, equalsLikeTlc, left, right);
|
|
1032
1029
|
|
|
1033
1030
|
const isStrictlySorted = (elements: Value[]) => {
|
|
1034
1031
|
for (let index = 1; index < elements.length; index++) {
|
|
@@ -1052,9 +1049,11 @@ export const createSet = (elements: Value[]): SetValue => {
|
|
|
1052
1049
|
// TLC builds a set enumeration without sorting it, so one whose elements it can't compare still
|
|
1053
1050
|
// evaluates.
|
|
1054
1051
|
export const createEnumeratedSet = (elements: Value[]): SetValue | MixedSetValue =>
|
|
1055
|
-
computeLikeTlcOnFailure<SetValue | MixedSetValue>(
|
|
1056
|
-
|
|
1057
|
-
() => ({ kind: "MixedSet", elements }),
|
|
1052
|
+
computeLikeTlcOnFailure<Value[], undefined, SetValue | MixedSetValue>(
|
|
1053
|
+
createSet,
|
|
1054
|
+
(mixed) => ({ kind: "MixedSet", elements: mixed }),
|
|
1055
|
+
elements,
|
|
1056
|
+
undefined,
|
|
1058
1057
|
);
|
|
1059
1058
|
|
|
1060
1059
|
export const EMPTY_SET = createSortedSet([]);
|
|
@@ -1596,6 +1595,38 @@ const getCombinedSets = (value: ObjectValue) =>
|
|
|
1596
1595
|
? [value.range]
|
|
1597
1596
|
: undefined;
|
|
1598
1597
|
|
|
1598
|
+
// Whether a value TLC builds alike at each evaluation and that enumerating, comparing or
|
|
1599
|
+
// fingerprinting it leaves alike, so that one evaluation can stand for the next. It holds no UNION or
|
|
1600
|
+
// \cup, which streams until TLC caches it, no lambda, which fingerprinting turns into a record, and
|
|
1601
|
+
// no record a comparison reorders.
|
|
1602
|
+
export const isSettledValue = (value: Value): boolean => {
|
|
1603
|
+
if (typeof value !== "object") return true;
|
|
1604
|
+
switch (value.kind) {
|
|
1605
|
+
case "ModelValue":
|
|
1606
|
+
case "Interval":
|
|
1607
|
+
return true;
|
|
1608
|
+
case "Set":
|
|
1609
|
+
return value.elements.every(isSettledValue);
|
|
1610
|
+
case "Function":
|
|
1611
|
+
return (
|
|
1612
|
+
value.functionClass !== "lambda" &&
|
|
1613
|
+
value.writtenKeys === undefined &&
|
|
1614
|
+
value.domain.every(isSettledValue) &&
|
|
1615
|
+
value.range.every(isSettledValue)
|
|
1616
|
+
);
|
|
1617
|
+
case "SetOperation":
|
|
1618
|
+
return (
|
|
1619
|
+
value.operator !== "\\cup" && isSettledValue(value.left) && isSettledValue(value.right)
|
|
1620
|
+
);
|
|
1621
|
+
case "FilteredSet":
|
|
1622
|
+
return isSettledValue(value.base);
|
|
1623
|
+
case "ProductSet":
|
|
1624
|
+
return value.factors.every(isSettledValue);
|
|
1625
|
+
default:
|
|
1626
|
+
return false;
|
|
1627
|
+
}
|
|
1628
|
+
};
|
|
1629
|
+
|
|
1599
1630
|
// Whether a set streams its elements in another order than the normalized set, so that a set of
|
|
1600
1631
|
// tuples, records, or functions it is a component of has to stream too.
|
|
1601
1632
|
const isStreamedApart = (value: Value): boolean => {
|
|
@@ -1870,17 +1901,20 @@ export const setTrace: { sets: Value[] | undefined; callStack?: TracedCallStack
|
|
|
1870
1901
|
};
|
|
1871
1902
|
|
|
1872
1903
|
// Takes a fast path, and computes as TLC does where it fails. TLC never takes the fast path, so
|
|
1873
|
-
// the failure's leftovers in the replay's trace go first.
|
|
1874
|
-
|
|
1875
|
-
|
|
1876
|
-
|
|
1904
|
+
// the failure's leftovers in the replay's trace go first. Both paths take their operands as
|
|
1905
|
+
// arguments, so a hot caller passes functions it doesn't allocate.
|
|
1906
|
+
export const computeLikeTlcOnFailure = <Left, Right, Result>(
|
|
1907
|
+
compute: (left: Left, right: Right) => Result,
|
|
1908
|
+
computeLikeTlc: (left: Left, right: Right, error: TlaEvaluationError) => Result,
|
|
1909
|
+
left: Left,
|
|
1910
|
+
right: Right,
|
|
1877
1911
|
): Result => {
|
|
1878
1912
|
const sets = setTrace.sets;
|
|
1879
1913
|
const callStack = setTrace.callStack;
|
|
1880
1914
|
const depth = sets?.length ?? 0;
|
|
1881
1915
|
const trace = callStack && { ...callStack, length: callStack.expressions.length };
|
|
1882
1916
|
try {
|
|
1883
|
-
return compute();
|
|
1917
|
+
return compute(left, right);
|
|
1884
1918
|
} catch (error) {
|
|
1885
1919
|
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
1886
1920
|
if (sets) sets.length = depth;
|
|
@@ -1889,7 +1923,7 @@ export const computeLikeTlcOnFailure = <Result>(
|
|
|
1889
1923
|
callStack.isFrozen = trace.isFrozen;
|
|
1890
1924
|
callStack.fingerprint = trace.fingerprint;
|
|
1891
1925
|
}
|
|
1892
|
-
return computeLikeTlc(error);
|
|
1926
|
+
return computeLikeTlc(left, right, error);
|
|
1893
1927
|
}
|
|
1894
1928
|
};
|
|
1895
1929
|
|
|
@@ -1902,19 +1936,20 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1902
1936
|
return isElement;
|
|
1903
1937
|
};
|
|
1904
1938
|
|
|
1939
|
+
const isInSortedSet = (element: Value, set: SetValue) => findIndex(set.elements, element) !== -1;
|
|
1940
|
+
|
|
1941
|
+
const isInSortedSetLikeTlc = (element: Value, set: SetValue) =>
|
|
1942
|
+
normalizedSets.has(set)
|
|
1943
|
+
? searchLikeTlc(element, set.elements).isFound
|
|
1944
|
+
: isElementOfLikeTlc(element, set.elements);
|
|
1945
|
+
|
|
1905
1946
|
const isElementOfSet = (element: Value, set: Value): boolean => {
|
|
1906
1947
|
if (!isSetValue(set)) throw new TlaEvaluationError(describeNonSetMembership(element, set));
|
|
1907
1948
|
switch (set.kind) {
|
|
1908
1949
|
case "Set":
|
|
1909
1950
|
// SetEnumValue.member compares the element with the set's.
|
|
1910
1951
|
cacheSet(element);
|
|
1911
|
-
return computeLikeTlcOnFailure(
|
|
1912
|
-
() => findIndex(set.elements, element) !== -1,
|
|
1913
|
-
() =>
|
|
1914
|
-
normalizedSets.has(set)
|
|
1915
|
-
? searchLikeTlc(element, set.elements).isFound
|
|
1916
|
-
: isElementOfLikeTlc(element, set.elements),
|
|
1917
|
-
);
|
|
1952
|
+
return computeLikeTlcOnFailure(isInSortedSet, isInSortedSetLikeTlc, element, set);
|
|
1918
1953
|
case "MixedSet":
|
|
1919
1954
|
return isElementOfLikeTlc(element, set.elements);
|
|
1920
1955
|
case "Interval":
|
|
@@ -2126,6 +2161,15 @@ export const createNonIntegerKeyError = (argument: Value) =>
|
|
|
2126
2161
|
// binary search with compareTo.
|
|
2127
2162
|
const LINEAR_SEARCH_LIMIT = 32;
|
|
2128
2163
|
|
|
2164
|
+
const failKeyLikeTlc = (domain: Value[], argument: Value, error: TlaEvaluationError): never => {
|
|
2165
|
+
if (valueVersion.is174 || domain.length < LINEAR_SEARCH_LIMIT) {
|
|
2166
|
+
domain.forEach((key) => equalsLikeTlc(key, argument));
|
|
2167
|
+
} else {
|
|
2168
|
+
findIndex(domain, argument, compareLikeTlc);
|
|
2169
|
+
}
|
|
2170
|
+
throw error;
|
|
2171
|
+
};
|
|
2172
|
+
|
|
2129
2173
|
// TLC looks a key up by the Java class of the function: a tuple or a record rejects a key of the
|
|
2130
2174
|
// wrong type, and another function rejects a non-integer for a domain it keeps as an interval, which
|
|
2131
2175
|
// TLC 1.7.4 doesn't. A key of another type than the domain's keys otherwise fails TLC's comparison.
|
|
@@ -2148,17 +2192,7 @@ const findKeyIndexLikeTlc = (
|
|
|
2148
2192
|
}
|
|
2149
2193
|
const identical = findIdenticalKey(domain, argument);
|
|
2150
2194
|
if (identical !== -1) return identical;
|
|
2151
|
-
return computeLikeTlcOnFailure(
|
|
2152
|
-
() => findIndex(domain, argument),
|
|
2153
|
-
(error) => {
|
|
2154
|
-
if (valueVersion.is174 || domain.length < LINEAR_SEARCH_LIMIT) {
|
|
2155
|
-
domain.forEach((key) => equalsLikeTlc(key, argument));
|
|
2156
|
-
} else {
|
|
2157
|
-
findIndex(domain, argument, compareLikeTlc);
|
|
2158
|
-
}
|
|
2159
|
-
throw error;
|
|
2160
|
-
},
|
|
2161
|
-
);
|
|
2195
|
+
return computeLikeTlcOnFailure(findIndex, failKeyLikeTlc, domain, argument);
|
|
2162
2196
|
};
|
|
2163
2197
|
|
|
2164
2198
|
export const applyFunction = (
|