tla-ts 0.0.1 → 0.0.3-dev.a50fc89

package/src/evaluate.ts

@@ -1,35 +1,51 @@
 import type {
   Bound,
   BoundPattern,
+  DecimalExpression,
   Definition,
   Expression,
   FunctionDefinition,
+  NumberExpression,
   OperatorParam,
   RecordField,
+  SourceRange,
 } from "./ast";
+import { getKindString } from "./builtins";
 import { TlaEvaluationError } from "./errors";
+import { EXIT_STATUS, setExitCode } from "./exit-codes";
 import { generateEvaluator } from "./codegen";
 import type { CheckerRuntime } from "./runtime";
 import { getReadVariables } from "./dependencies";
-import { mapChildren, substitutedExpressions } from "./instances";
+import { contextualApplications, mapChildren, substitutedExpressions } from "./instances";
 import { isEnabled } from "./successors";
 import {
   applyFunction,
-  checkInteger,
+  combineHash,
+  compareValues,
   createFunction,
-  createSet,
+  createEnumeratedSet,
   createSortedFunction,
   createSortedSet,
+  createWrittenRecord,
   createTuple,
   formatValue,
+  getDomain,
+  getFunctionDomain,
+  getIntervalElements,
   getSequenceElements,
   getValueHash,
   isEnumerable,
+  isFunctionValue,
+  isOverriddenSet,
   isSameValue,
+  markLambdaFunction,
   isSetValue,
+  MAXIMUM_INTEGER,
+  MINIMUM_INTEGER,
   toFiniteSet,
   updateFunction,
   valuesEqual,
+  type LazyFunctionSource,
   type LazyFunctionValue,
   type Value,
 } from "./values";
@@ -42,6 +58,7 @@ export interface OperatorValue {
   arity: number;
   call: (args: Value[]) => Value;
   expression?: Expression;
+  literalBody?: Value;
 }
 
 export type BuiltinArgument = Value | OperatorValue;
@@ -65,7 +82,7 @@ export interface Closure {
   scope: Scope | undefined;
 }
 
-export type Operator = Closure | Builtin | OperatorValue;
+type Operator = Closure | Builtin | OperatorValue;
 
 export interface Thunk {
   kind: "Thunk";
@@ -76,10 +93,7 @@ export interface Thunk {
   cache: Value | undefined;
 }
 
-export type Binding =
-  | { kind: "Value"; value: Value }
-  | Thunk
-  | { kind: "Operator"; operator: Operator };
+type Binding = { kind: "Value"; value: Value } | Thunk | { kind: "Operator"; operator: Operator };
 
 export interface Scope {
   name: string;
@@ -111,6 +125,12 @@ export type Evaluator = (context: Context) => Value;
 
 type ArgumentBinder = (context: Context) => Binding;
 
+interface CompiledStep {
+  kind: "Field" | "Index";
+  name: string;
+  args: Evaluator[];
+}
+
 type GlobalName =
   | { kind: "Variable"; index: number }
   | { kind: "Value"; value: Value }
@@ -118,9 +138,87 @@ type GlobalName =
 
 const EXCEPT_AT = "@";
 
-const describeLocation = (expression: Expression) =>
+export const describeLocation = (expression: Expression) =>
   `line ${expression.location.line}, column ${expression.location.column}`;
 
+export const formatRange = (range: SourceRange) =>
+  `line ${range.start.line}, col ${range.start.column} to line ${range.end.line}, col ${range.end.column} of module ${range.module}`;
+
+export const describeRange = (expression: Expression) => {
+  const range = expression.location.range;
+  return range ? formatRange(range) : describeLocation(expression);
+};
+
+export const getConditionError = (expression: Expression, value: Value) =>
+  new TlaEvaluationError(
+    `A non-boolean expression (${getKindString(value)}) was used as the condition of an IF.\n${describeRange(expression)}`,
+  );
+
+// TLC parses an infix chain of /\ as nested binary conjunctions and a bulleted list as one
+// conjunction list, and it words the error differently for each.
+export const getConjunctError = (
+  expression: Expression & { kind: "And" | "Or" },
+  index: number,
+  value: Value,
+) => {
+  const range = expression.location.range;
+  const isBulleted =
+    range?.start.line === expression.location.line &&
+    range.start.column === expression.location.column;
+  if (isBulleted || !range) {
+    const operand = expression.operands[index];
+    // SANY prints a numeral as its value instead of its location.
+    const description = operand.kind === "Number" ? String(operand.value) : describeRange(operand);
+    return new TlaEvaluationError(
+      `A non-boolean expression (${getKindString(value)}) was used as a formula in a conjunction.\n${description}`,
+    );
+  }
+  const end = expression.operands[Math.max(index, 1)].location.range?.end ?? range.end;
+  return new TlaEvaluationError(
+    `Attempted to evaluate an expression of form P /\\ Q when ${index === 0 ? "P" : "Q"} was\n${getKindString(value)}.\n${describeRange({ ...expression, location: { ...expression.location, range: { ...range, end } } })}`,
+  );
+};
+
+export const getFieldError =
+  (expression: Expression & { kind: "FieldAccess" }) => (record: Value) =>
+    `Attempted to select nonexistent field "${expression.field}" from the record\n${formatValue(record)}\n${describeRange(expression)}`;
+
+export const getDomainOperator = (expression: Expression) => (value: Value) => {
+  if (!isFunctionValue(value)) {
+    throw new TlaEvaluationError(
+      `Attempted to apply the operator DOMAIN to a non-function\n(${getKindString(value)})\n${describeRange(expression)}`,
+    );
+  }
+  return getDomain(value);
+};
+
+export const getSubsetOperator =
+  (expression: Expression, builtin: Builtin) => (left: Value, right: Value) => {
+    if (!isSetValue(left) || isOverriddenSet(left)) {
+      throw new TlaEvaluationError(
+        `Attempted to evaluate an expression of form S \\subseteq T, but S was not enumerable.\n${describeRange(expression)}`,
+      );
+    }
+    return builtin.evaluate([left, right]);
+  };
+
+// TLC rejects a decimal, or an integer literal too big for it, while it processes the spec.
+export const createRealNumberError = (expression: DecimalExpression) =>
+  setExitCode(
+    new TlaEvaluationError(
+      `TLC can't handle real numbers: ${expression.text} at ${describeLocation(expression)}`,
+    ),
+    EXIT_STATUS.configParseError,
+  );
+
+export const createBigNumberError = (expression: NumberExpression) =>
+  setExitCode(
+    new TlaEvaluationError(
+      `TLC can't handle a number this big: ${expression.text ?? expression.value} at ${describeLocation(expression)}`,
+    ),
+    EXIT_STATUS.error,
+  );
+
 export const lookupScope = (scope: Scope | undefined, name: string): Binding | undefined => {
   for (let current = scope; current; current = current.parent) {
     if (current.name === name) return current.binding;
@@ -134,11 +232,7 @@ export const bindValue = (scope: Scope | undefined, name: string, value: Value):
   parent: scope,
 });
 
-export const bindPattern = (
-  scope: Scope | undefined,
-  pattern: BoundPattern,
-  value: Value,
-): Scope => {
+const bindPattern = (scope: Scope | undefined, pattern: BoundPattern, value: Value) => {
   if (pattern.kind === "Name") return bindValue(scope, pattern.name, value);
   const elements = getSequenceElements(value);
   if (!elements || elements.length !== pattern.names.length) {
@@ -149,7 +243,7 @@ export const bindPattern = (
   return pattern.names.reduce<Scope | undefined>(
     (current, name, index) => bindValue(current, name, elements[index]),
     scope,
-  ) as Scope;
+  );
 };
 
 const withScope = (context: Context, scope: Scope | undefined): Context => ({
@@ -171,6 +265,7 @@ export const expectBoolean = (value: Value, description: string) => {
 export const getChildren = (expression: Expression): Expression[] => {
   switch (expression.kind) {
     case "Number":
+    case "Decimal":
     case "String":
     case "Identifier":
     case "OperatorReference":
@@ -296,13 +391,37 @@ export const isConstantLevel = (definition: Definition, environment: Environment
   return isConstant;
 };
 
+const getBoundExplanation = (set: Value, text: string) => {
+  const quantified = `universally (\\A) or existentially (\\E) quantify over ${text}, because this would require checking an\ninfinite number of cases.`;
+  if (typeof set === "object" && set.kind === "SequenceSet") {
+    return `In TLA+, Seq(S) represents the set of all finite sequences whose elements come from the set S. Even when S\nis a finite set, the number of possible sequences in Seq(S) is unbounded because sequences can have any\nfinite length (e.g., length 0, 1, 2, and so on). As a result, TLC cannot evaluate expressions that\n${quantified} Note that for a finite set of sequences s, TLC handles s \\subseteq Seq(S).\nSee https://explain.tlapl.us/seq-unenumerable for additional details.`;
+  }
+  if (
+    typeof set === "object" &&
+    set.kind === "InfiniteSet" &&
+    set.name !== "STRING" &&
+    set.name !== "Any"
+  ) {
+    return `The set ${set.name} contains infinitely many elements. As a result, TLC cannot evaluate expressions that\n${quantified} Note that TLC handles set membership like T \\subseteq ${set.name} for any finite set T.`;
+  }
+  return undefined;
+};
+
+// TLC enumerates every set except the ones it implements in Java, so any other set fails as its own
+// class does.
 export const getEnumeratedElements = (set: Value, expression: Expression) => {
-  if (!isEnumerable(set)) {
+  if (!isSetValue(set) || isOverriddenSet(set)) {
+    const text = formatValue(set);
+    const explanation = getBoundExplanation(set, text);
     throw new TlaEvaluationError(
-      `TLC encountered a non-enumerable quantifier bound ${formatValue(set)} at ${describeLocation(expression)}`,
+      explanation === undefined
+        ? `TLC encountered a non-enumerable quantifier bound\n${text}.\n${describeRange(expression)}`
+        : `TLC encountered the non-enumerable quantifier bound\n${text}\n${describeRange(expression)}\n${explanation}`,
     );
   }
-  return toFiniteSet(set).elements;
+  return typeof set === "object" && set.kind === "Interval"
+    ? getIntervalElements(set)
+    : toFiniteSet(set).elements;
 };
 
 export const forEachBinding = (
@@ -336,14 +455,66 @@ export const bindArgument = (bounds: Bound[], scope: Scope | undefined, argument
   );
 };
 
+// TLC prints a function it can't enumerate as its parameters and the location of its body. It
+// prints only the first name of a group such as `m, n \in S`.
+interface LazyFunctionTemplate {
+  parameters: { index: number; name: string }[];
+  body: string;
+}
+
+const lazyFunctionTemplates = new WeakMap<Expression, LazyFunctionTemplate>();
+
+const getLazyFunctionTemplate = (bounds: Bound[], body: Expression) => {
+  const cached = lazyFunctionTemplates.get(body);
+  if (cached) return cached;
+  const range = body.location.range;
+  if (!range) return undefined;
+  const template = {
+    parameters: bounds.flatMap((bound, index) =>
+      index > 0 && bounds[index - 1].set === bound.set
+        ? []
+        : [
+            {
+              index,
+              name:
+                bound.pattern.kind === "Name"
+                  ? bound.pattern.name
+                  : `<<${bound.pattern.names.join(", ")}>>`,
+            },
+          ],
+    ),
+    body: formatRange(range),
+  };
+  lazyFunctionTemplates.set(body, template);
+  return template;
+};
+
+const getLazyFunctionSource = (bounds: Bound[], body: Expression, domain: Value) => {
+  const template = getLazyFunctionTemplate(bounds, body);
+  if (!template) return undefined;
+  const domains =
+    bounds.length > 1 && typeof domain === "object" && domain.kind === "ProductSet"
+      ? domain.factors
+      : [domain];
+  return {
+    parameters: template.parameters.map((parameter) => ({
+      name: parameter.name,
+      domain: domains[parameter.index],
+    })),
+    body: template.body,
+  };
+};
+
 const createLazyFunction = (
   domain: Value,
   compute: (argument: Value, self: LazyFunctionValue) => Value,
-): LazyFunctionValue => {
+  source: LazyFunctionSource | undefined,
+) => {
   const memo = new Map<number, Value[]>();
   const self: LazyFunctionValue = {
     kind: "LazyFunction",
     domain,
+    source,
     apply: (argument) => {
       const hash = getValueHash(argument);
       const bucket = memo.get(hash);
@@ -362,18 +533,29 @@ const createLazyFunction = (
   return self;
 };
 
-const createRecursiveFunction = (definition: FunctionDefinition, context: Context) =>
-  createLazyFunction(getBoundsDomain(definition.bounds, context), (argument, self) =>
-    evaluate(
-      definition.body,
-      withScope(
-        context,
-        bindArgument(definition.bounds, bindValue(undefined, definition.name, self), argument),
+const createRecursiveFunction = (definition: FunctionDefinition, context: Context) => {
+  const domain = getBoundsDomain(definition.bounds, context);
+  const functionValue = createLazyFunction(
+    domain,
+    (argument, self) =>
+      evaluate(
+        definition.body,
+        withScope(
+          context,
+          bindArgument(definition.bounds, bindValue(undefined, definition.name, self), argument),
+        ),
       ),
-    ),
+    getLazyFunctionSource(definition.bounds, definition.body, domain),
   );
+  return definition.bounds.length === 1 ? markLambdaFunction(functionValue) : functionValue;
+};
+
+const evaluateDefinitionBody = (definition: Definition, context: Context) =>
+  definition.kind === "Function"
+    ? createRecursiveFunction(definition, context)
+    : evaluate(definition.body, context);
 
-const evaluateDefinitionValue = (definition: Definition, context: Context): Value => {
+const evaluateDefinitionValue = (definition: Definition, context: Context) => {
   const isConstant = isConstantLevel(definition, context.environment);
   const cached = isConstant ? context.environment.definitionValues.get(definition) : undefined;
   if (cached !== undefined) return cached;
@@ -383,11 +565,11 @@ const evaluateDefinitionValue = (definition: Definition, context: Context): Valu
     );
   }
   const topLevel = withScope(context, undefined);
-  const value =
-    definition.kind === "Function"
-      ? createRecursiveFunction(definition, topLevel)
-      : evaluate(definition.body, topLevel);
-  if (isConstant) context.environment.definitionValues.set(definition, value);
+  if (!isConstant) return evaluateDefinitionBody(definition, topLevel);
+  const value = context.environment.runtime.evaluateAtStartup(() =>
+    evaluateDefinitionBody(definition, topLevel),
+  );
+  context.environment.definitionValues.set(definition, value);
   return value;
 };
 
@@ -477,11 +659,7 @@ const evaluateOperatorArgument = (expression: Expression, context: Context): Ope
   return operator;
 };
 
-export const callOperatorWithValues = (
-  operator: Operator,
-  args: Value[],
-  context: Context,
-): Value => {
+const callOperatorWithValues = (operator: Operator, args: Value[], context: Context): Value => {
   if (operator.kind === "Builtin") return operator.evaluate(args, context);
   if (operator.kind === "Operator") return operator.call(args);
   const scope = operator.params.reduce<Scope | undefined>(
@@ -499,6 +677,11 @@ const toOperatorValue = (operator: Operator, context: Context): OperatorValue =>
         name: operator.name,
         arity: getArity(operator),
         call: (args) => callOperatorWithValues(operator, args, context),
+        literalBody:
+          operator.kind === "Closure" &&
+          (operator.body.kind === "Number" || operator.body.kind === "String")
+            ? operator.body.value
+            : undefined,
       };
 
 const isOperatorArgument = (expression: Expression, context: Context) => {
@@ -551,7 +734,9 @@ const compileArgumentBinder = (argument: Expression, environment: Environment):
     if (global === undefined) {
       return (context) => {
         const binding = lookupScope(context.scope, argument.name);
-        return binding?.kind === "Value" ? binding : createThunk(argument, context);
+        return binding?.kind === "Value" || binding?.kind === "Thunk"
+          ? binding
+          : createThunk(argument, context);
       };
     }
   }
@@ -590,7 +775,7 @@ export const bindOperatorArguments = (
   return scope;
 };
 
-const callOperator = (operator: Operator, args: Expression[], context: Context): Value => {
+const callOperator = (operator: Operator, args: Expression[], context: Context) => {
   if (operator.kind === "Closure") {
     return evaluate(
       operator.body,
@@ -609,7 +794,11 @@ const callOperator = (operator: Operator, args: Expression[], context: Context):
   );
 };
 
-export const bindDefinitions = (definitions: Definition[], context: Context): Scope | undefined =>
+export const bindDefinitions = (
+  definitions: Definition[],
+  context: Context,
+  reevaluated?: ReadonlySet<Definition>,
+): Scope | undefined =>
   definitions.reduce<Scope | undefined>((scope, definition) => {
     const node: Scope = {
       name: definition.name,
@@ -633,7 +822,7 @@ export const bindDefinitions = (definitions: Definition[], context: Context): Sc
       };
       return node;
     }
-    if (definition.params.length > 0) {
+    if (definition.params.length > 0 || reevaluated?.has(definition)) {
       node.binding = {
         kind: "Operator",
         operator: {
@@ -684,10 +873,10 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
   throw new TlaEvaluationError(`Unknown identifier ${name} at ${describeLocation(expression)}`);
 };
 
-const isTlcInteger = (value: number) =>
-  Number.isInteger(value) && value <= 2147483647 && value >= -2147483648;
+export const isTlcInteger = (value: number) =>
+  Number.isInteger(value) && value <= MAXIMUM_INTEGER && value >= MINIMUM_INTEGER;
 
-export const IMPURE_BUILTINS = new Set([
+const IMPURE_BUILTINS = new Set([
   "Print",
   "PrintT",
   "Assert",
@@ -700,6 +889,58 @@ export const IMPURE_BUILTINS = new Set([
 export const isImpureBuiltin = (name: string, environment: Environment) =>
   IMPURE_BUILTINS.has(name) || environment.builtins.get(name)?.isStateLevel === true;
 
+const impureDefinitions = new WeakMap<Definition, boolean>();
+
+const isEvaluatedOnce = (definition: Definition, environment: Environment) =>
+  definition.kind === "Operator" &&
+  definition.params.length === 0 &&
+  isConstantLevel(definition, environment);
+
+const callsImpureBuiltin = (expression: Expression, environment: Environment): boolean => {
+  const name =
+    expression.kind === "Identifier"
+      ? expression.name
+      : expression.kind === "Apply" || expression.kind === "OperatorReference"
+        ? expression.operator
+        : undefined;
+  if (name !== undefined && !isLocallyResolved(expression)) {
+    const definition = getDefinition(name, environment);
+    if (!definition && isImpureBuiltin(name, environment)) return true;
+    if (
+      definition &&
+      !isEvaluatedOnce(definition, environment) &&
+      isImpureDefinition(definition, environment)
+    ) {
+      return true;
+    }
+  }
+  return getChildren(expression).some((child) => callsImpureBuiltin(child, environment));
+};
+
+// TLC evaluates a constant definition without parameters once, so only other definitions pass
+// on the side effects and random choices of the builtins they call.
+const isImpureDefinition = (definition: Definition, environment: Environment): boolean => {
+  const cached = impureDefinitions.get(definition);
+  if (cached !== undefined) return cached;
+  impureDefinitions.set(definition, false);
+  const isImpure =
+    callsImpureBuiltin(definition.body, environment) ||
+    (definition.kind === "Function" &&
+      definition.bounds.some((bound) => callsImpureBuiltin(bound.set, environment)));
+  impureDefinitions.set(definition, isImpure);
+  return isImpure;
+};
+
+// TLC's next-state generator does not bind LET definitions to values, so each reference to one
+// that calls an impure builtin evaluates it again.
+export const getReevaluatedDefinitions = (definitions: Definition[], environment: Environment) =>
+  new Set(definitions.filter((definition) => isImpureDefinition(definition, environment)));
+
+export const isImpure = (environment: Environment) =>
+  [...environment.definitions.values()].some((definition) =>
+    isImpureDefinition(definition, environment),
+  );
+
 const closedConstants = new WeakMap<Expression, boolean>();
 
 export const isClosedConstant = (expression: Expression, environment: Environment): boolean => {
@@ -742,7 +983,7 @@ const isClosedIn = (
   expression: Expression,
   environment: Environment,
   bound: ReadonlySet<string>,
-): boolean =>
+) =>
   bound.size === 0
     ? isClosedConstant(expression, environment)
     : computeIsClosedConstant(expression, environment, bound);
@@ -760,28 +1001,24 @@ const computeIsClosedConstant = (
   if (expression.kind === "Identifier") {
     const global = findGlobalName(expression.name, environment);
     if (global?.kind === "Value") return true;
-    return (
-      global?.kind === "Definition" &&
-      global.definition.kind === "Operator" &&
-      global.definition.params.length === 0 &&
-      isConstantLevel(global.definition, environment)
-    );
+    return global?.kind === "Definition" && isEvaluatedOnce(global.definition, environment);
   }
   if (expression.kind === "Apply") {
     if (isImpureBuiltin(expression.operator, environment) || expression.operator === "~>") {
       return false;
     }
     const operator = resolveGlobalOperator(expression.operator, environment);
-    const isPure =
-      operator?.kind === "Builtin" ||
-      (operator?.kind === "Closure" &&
-        (() => {
-          const definition = environment.definitions.get(
-            environment.substitutions.get(expression.operator) ?? expression.operator,
-          );
-          return definition !== undefined && isConstantLevel(definition, environment);
-        })());
-    if (!isPure || operator === undefined) return false;
+    if (operator?.kind !== "Builtin" && operator?.kind !== "Closure") return false;
+    if (operator.kind === "Closure") {
+      const definition = getDefinition(expression.operator, environment);
+      if (
+        !definition ||
+        !isConstantLevel(definition, environment) ||
+        isImpureDefinition(definition, environment)
+      ) {
+        return false;
+      }
+    }
     const params = operator.kind === "Closure" ? operator.params : [];
     const hasOperatorArgument = params.some((param) => param.arity > 0);
     if (hasOperatorArgument) return false;
@@ -855,7 +1092,7 @@ export const getEvaluator = (expression: Expression, environment: Environment):
 
 const entryEvaluators = new WeakMap<Expression, Evaluator>();
 
-const getEntryEvaluator = (expression: Expression, environment: Environment): Evaluator => {
+const getEntryEvaluator = (expression: Expression, environment: Environment) => {
   const cached = entryEvaluators.get(expression);
   if (cached) return cached;
   const evaluator =
@@ -1031,18 +1268,79 @@ export const compileArgumentScope = (
   };
 };
 
+interface MemoizedCall {
+  args: Value[];
+  value: Value;
+}
+
+const MEMOIZED_CALL_LIMIT = 1 << 16;
+
+const callMemos = new WeakMap<Closure, { calls: Map<number, MemoizedCall[]>; size: number }>();
+
+const getCallMemo = (closure: Closure) => {
+  const cached = callMemos.get(closure);
+  if (cached) return cached;
+  const memo = { calls: new Map<number, MemoizedCall[]>(), size: 0 };
+  callMemos.set(closure, memo);
+  return memo;
+};
+
+const getArgumentValues = (scope: Scope | undefined, arity: number) => {
+  const values: Value[] = [];
+  for (let current = scope; values.length < arity; current = current?.parent) {
+    if (current?.binding.kind !== "Value") return undefined;
+    values.push(current.binding.value);
+  }
+  return values;
+};
+
+const isSameArguments = (left: Value[], right: Value[]) =>
+  left.every((value, index) => isSameValue(value, right[index]));
+
+// A constant-level operator without side effects yields the same value for the same arguments,
+// so its calls with evaluated arguments share one result.
+const isMemoizable = (expression: Expression & { kind: "Apply" }, environment: Environment) => {
+  const definition = getDefinition(expression.operator, environment);
+  return (
+    definition?.kind === "Operator" &&
+    definition.params.length > 0 &&
+    definition.params.every((param) => param.arity === 0) &&
+    isConstantLevel(definition, environment) &&
+    !isImpureDefinition(definition, environment)
+  );
+};
+
 const compileClosureCall = (
   closure: Closure,
   args: Expression[],
   environment: Environment,
+  isMemoized: boolean,
 ): Evaluator => {
   const bindArguments = compileArgumentScope(closure, args, environment);
   const compiled = { body: undefined as Evaluator | undefined };
-  return (context) => {
-    const scope = bindArguments(context);
+  const evaluateBody = (scope: Scope | undefined, context: Context) => {
     compiled.body ??= getEntryEvaluator(closure.body, environment);
     return compiled.body({ environment, scope, state: context.state, next: context.next });
   };
+  if (!isMemoized) return (context) => evaluateBody(bindArguments(context), context);
+  const memo = getCallMemo(closure);
+  return (context) => {
+    const scope = bindArguments(context);
+    const values = getArgumentValues(scope, args.length);
+    if (!values) return evaluateBody(scope, context);
+    let hash = values.length;
+    for (const value of values) hash = combineHash(hash, getValueHash(value));
+    const bucket = memo.calls.get(hash);
+    const known = bucket?.find((call) => isSameArguments(call.args, values));
+    if (known) return known.value;
+    const value = evaluateBody(scope, context);
+    if (memo.size < MEMOIZED_CALL_LIMIT) {
+      memo.size++;
+      if (bucket) bucket.push({ args: values, value });
+      else memo.calls.set(hash, [{ args: values, value }]);
+    }
+    return value;
+  };
 };
 
 const compileApply = (
@@ -1065,7 +1363,29 @@ const compileApply = (
   const global = isLocallyResolved(expression)
     ? undefined
     : resolveGlobalOperator(expression.operator, environment);
-  if (global?.kind === "Closure") return compileClosureCall(global, args, environment);
+  if (global?.kind === "Closure") {
+    return compileClosureCall(global, args, environment, isMemoizable(expression, environment));
+  }
+  if (global?.kind === "Builtin" && global.name === "DOMAIN") {
+    const operand = getEvaluator(args[0], environment);
+    const domain = getDomainOperator(expression);
+    return (context) => domain(operand(context));
+  }
+  // TLC sorts the value of a constant TLCEval argument only where no context binds a name.
+  if (global?.kind === "Builtin" && global.name === "TLCEval" && args.length === 1) {
+    const operand = getEvaluator(args[0], environment);
+    if (contextualApplications.has(expression) || isStateDependent(args[0], environment)) {
+      return operand;
+    }
+    return (context) =>
+      context.scope === undefined ? global.evaluate([operand(context)]) : operand(context);
+  }
+  if (global?.kind === "Builtin" && global.name === "\\subseteq" && args.length === 2) {
+    const left = getEvaluator(args[0], environment);
+    const right = getEvaluator(args[1], environment);
+    const subset = getSubsetOperator(expression, global);
+    return (context) => subset(left(context), right(context));
+  }
   if (global?.kind === "Builtin") return compileBuiltinCall(global, args, environment);
   return (context) => {
     const operator = resolveOperator(expression.operator, context);
@@ -1134,7 +1454,7 @@ const compileQuantifier = (
   };
 };
 
-const lookupKey = (pattern: BoundPattern, scope: Scope | undefined): Value | undefined => {
+const lookupKey = (pattern: BoundPattern, scope: Scope | undefined) => {
   if (pattern.kind === "Tuple") {
     return createTuple(
       pattern.names.map((name) => {
@@ -1147,10 +1467,21 @@ const lookupKey = (pattern: BoundPattern, scope: Scope | undefined): Value | und
   return binding?.kind === "Value" ? binding.value : undefined;
 };
 
+// TLC keeps a function constructor lazy when it is the function of an application, or the base of
+// an EXCEPT that is, so it evaluates the body only at the arguments it is applied to.
+const keptLazyExpressions = new WeakSet<Expression>();
+
+export const keepLazy = (expression: Expression) => {
+  if (expression.kind === "FunctionConstruction" || expression.kind === "Except") {
+    keptLazyExpressions.add(expression);
+  }
+};
+
 const compileFunctionConstruction = (
   expression: Expression & { kind: "FunctionConstruction" },
   environment: Environment,
 ): Evaluator => {
+  const isKeptLazy = keptLazyExpressions.has(expression);
   const body = getEvaluator(expression.body, environment);
   const bounds = expression.bounds;
   const bound = bounds[0];
@@ -1158,17 +1489,22 @@ const compileFunctionConstruction = (
   const set = getEvaluator(bound.set, environment);
   return (context) => {
     const domain = isSingleName ? set(context) : getBoundsDomain(bounds, context);
-    if (expression.isRecursive || !isEnumerable(domain)) {
-      return createLazyFunction(domain, (argument) =>
-        body(withScope(context, bindArgument(bounds, context.scope, argument))),
+    if (expression.isRecursive || isKeptLazy || !isEnumerable(domain)) {
+      const functionValue = createLazyFunction(
+        domain,
+        (argument) => body(withScope(context, bindArgument(bounds, context.scope, argument))),
+        getLazyFunctionSource(bounds, expression.body, domain),
       );
+      return bounds.length === 1 ? markLambdaFunction(functionValue) : functionValue;
     }
     if (isSingleName && bound.pattern.kind === "Name") {
       const name = bound.pattern.name;
-      const keys = toFiniteSet(domain).elements;
-      return createSortedFunction(
-        keys,
-        keys.map((key) => body(withScope(context, bindValue(context.scope, name, key)))),
+      const keys = getFunctionDomain(domain);
+      return markLambdaFunction(
+        createSortedFunction(
+          keys,
+          keys.map((key) => body(withScope(context, bindValue(context.scope, name, key)))),
+        ),
       );
     }
     const pairs: [Value, Value][] = [];
@@ -1188,21 +1524,22 @@ const compileExcept = (
   expression: Expression & { kind: "Except" },
   environment: Environment,
 ): Evaluator => {
-  const fn = getEvaluator(expression.function, environment);
+  const isKeptLazy = keptLazyExpressions.has(expression);
+  if (isKeptLazy) keepLazy(expression.function);
+  const evaluateFunction = getEvaluator(expression.function, environment);
   const updates = expression.updates.map((update) => ({
-    path: update.path.map((step) =>
+    path: update.path.map((step): CompiledStep =>
       step.kind === "Field"
-        ? { kind: "Field" as const, name: step.name, args: [] as Evaluator[] }
+        ? { kind: "Field", name: step.name, args: [] }
         : {
-            kind: "Index" as const,
+            kind: "Index",
             name: "",
             args: step.args.map((arg) => getEvaluator(arg, environment)),
           },
     ),
     value: getEvaluator(update.value, environment),
   }));
-  type CompiledStep = (typeof updates)[number]["path"][number];
-  const getKey = (step: CompiledStep, context: Context): Value => {
+  const getKey = (step: CompiledStep, context: Context) => {
     if (step.kind === "Field") return step.name;
     if (step.args.length === 1) return step.args[0](context);
     return createTuple(step.args.map((arg) => arg(context)));
@@ -1217,12 +1554,15 @@ const compileExcept = (
     if (depth === path.length) {
       return value(withScope(context, bindValue(context.scope, EXCEPT_AT, current)));
     }
-    return updateFunction(current, getKey(path[depth], context), (previous) =>
-      update(previous, path, depth + 1, context, value),
+    return updateFunction(
+      current,
+      getKey(path[depth], context),
+      (previous) => update(previous, path, depth + 1, context, value),
+      isKeptLazy && depth === 0,
     );
   };
   return (context) => {
-    let current = fn(context);
+    let current = evaluateFunction(context);
     for (const item of updates) current = update(current, item.path, 0, context, item.value);
     return current;
   };
@@ -1244,7 +1584,8 @@ const compileSetComprehension = (
           "a set filter predicate",
         );
       const isReducible =
-        typeof base === "object" && (base.kind === "Set" || base.kind === "Interval");
+        typeof base === "object" &&
+        (base.kind === "Set" || base.kind === "MixedSet" || base.kind === "Interval");
       if (!isReducible) {
         if (isSetValue(base)) return { kind: "FilteredSet", base, test };
         throw new TlaEvaluationError(
@@ -1262,7 +1603,7 @@ const compileSetComprehension = (
         elements.push(mapped(withScope(context, scope)));
         return false;
       });
-      return createSet(elements);
+      return createEnumeratedSet(elements);
     };
   }
   const set = expression.set;
@@ -1284,7 +1625,7 @@ const compileSetComprehension = (
     });
     if (chosen.value === undefined) {
       throw new TlaEvaluationError(
-        `Attempted to compute CHOOSE x \\in S : P, but no element of S satisfies P at ${describeLocation(expression)}`,
+        `Attempted to compute the value of an expression of form\nCHOOSE x \\in S: P, but no element of S satisfied P.\n${describeRange(expression)}`,
       );
     }
     return chosen.value;
@@ -1292,7 +1633,7 @@ const compileSetComprehension = (
 };
 
 const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
-  const fields = [...recordFields].sort((left, right) => (left.name < right.name ? -1 : 1));
+  const fields = [...recordFields].sort((left, right) => compareValues(left.name, right.name));
   const hasDuplicates = fields.some(
     (field, index) => index > 0 && fields[index - 1].name === field.name,
   );
@@ -1303,7 +1644,16 @@ const compileRecord = (recordFields: RecordField[], environment: Environment): E
         fields.map((field, index): [Value, Value] => [field.name, values[index](context)]),
       );
   }
-  const names: Value[] = fields.map((field) => field.name);
+  const names = fields.map((field) => field.name);
+  const writtenNames = recordFields.map((field) => field.name);
+  if (writtenNames.some((name, index) => name !== names[index])) {
+    return (context) =>
+      createWrittenRecord(
+        names,
+        values.map((value) => value(context)),
+        writtenNames,
+      );
+  }
   return (context) =>
     createSortedFunction(
       names,
@@ -1311,25 +1661,21 @@ const compileRecord = (recordFields: RecordField[], environment: Environment): E
     );
 };
 
-const createUnchanged = (expression: Expression, location: Expression["location"]): Expression => ({
-  kind: "Unchanged",
-  expression,
-  location,
-});
-
-const throwing =
-  (createError: () => Error): Evaluator =>
-  () => {
-    throw createError();
-  };
-
 const compile = (expression: Expression, environment: Environment): Evaluator => {
   const child = (node: Expression) => getEvaluator(node, environment);
   switch (expression.kind) {
     case "Number": {
       const value = expression.value;
-      return isTlcInteger(value) ? () => value : () => checkInteger(value);
+      return isTlcInteger(value)
+        ? () => value
+        : () => {
+            throw createBigNumberError(expression);
+          };
     }
+    case "Decimal":
+      return () => {
+        throw createRealNumberError(expression);
+      };
     case "String": {
       const value = expression.value;
       return () => value;
@@ -1340,17 +1686,18 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
       return compileApply(expression, environment);
     case "OperatorReference":
     case "Lambda":
-      return throwing(
-        () =>
-          new TlaEvaluationError(
-            `An operator cannot be used as a value at ${describeLocation(expression)}`,
-          ),
-      );
+      return () => {
+        throw new TlaEvaluationError(
+          `An operator cannot be used as a value at ${describeLocation(expression)}`,
+        );
+      };
     case "And": {
       const operands = expression.operands.map(child);
       return (context) => {
         for (let index = 0; index < operands.length; index++) {
-          if (!expectBoolean(operands[index](context), "a conjunct")) return false;
+          const value = operands[index](context);
+          if (typeof value !== "boolean") throw getConjunctError(expression, index, value);
+          if (!value) return false;
         }
         return true;
       };
@@ -1393,10 +1740,11 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
       const condition = child(expression.condition);
       const consequent = child(expression.consequent);
       const alternative = child(expression.alternative);
-      return (context) =>
-        expectBoolean(condition(context), "an IF condition")
-          ? consequent(context)
-          : alternative(context);
+      return (context) => {
+        const value = condition(context);
+        if (typeof value !== "boolean") throw getConditionError(expression, value);
+        return value ? consequent(context) : alternative(context);
+      };
     }
     case "Case": {
       const arms = expression.arms.map((arm) => ({
@@ -1421,19 +1769,18 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
     case "Exists":
       return compileQuantifier(expression, environment);
     case "UnboundedQuantifier":
-      return throwing(
-        () =>
-          new TlaEvaluationError(
-            `TLC cannot evaluate an unbounded quantifier at ${describeLocation(expression)}`,
-          ),
-      );
+      return () => {
+        throw new TlaEvaluationError(
+          `TLC cannot evaluate an unbounded quantifier at ${describeLocation(expression)}`,
+        );
+      };
     case "Choose":
     case "SetFilter":
     case "SetMap":
       return compileSetComprehension(expression, environment);
     case "SetEnumeration": {
       const elements = expression.elements.map(child);
-      return (context) => createSet(elements.map((element) => element(context)));
+      return (context) => createEnumeratedSet(elements.map((element) => element(context)));
     }
     case "Tuple": {
       const elements = expression.elements.map(child);
@@ -1450,7 +1797,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
       return compileRecord(expression.fields, environment);
     case "RecordSet": {
       const fields = [...expression.fields].sort((left, right) =>
-        left.name < right.name ? -1 : 1,
+        compareValues(left.name, right.name),
       );
       const names = fields.map((field) => field.name);
       const sets = fields.map((field) => child(field.value));
@@ -1469,18 +1816,21 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
         return binding.value;
       };
     case "FunctionApplication": {
-      const fn = child(expression.function);
+      keepLazy(expression.function);
+      const evaluateFunction = child(expression.function);
       const args = expression.args.map(child);
       if (args.length === 1) {
         const argument = args[0];
-        return (context) => applyFunction(fn(context), argument(context));
+        return (context) => applyFunction(evaluateFunction(context), argument(context));
       }
-      return (context) => applyFunction(fn(context), createTuple(args.map((arg) => arg(context))));
+      return (context) =>
+        applyFunction(evaluateFunction(context), createTuple(args.map((arg) => arg(context))));
     }
     case "FieldAccess": {
       const record = child(expression.record);
       const field = expression.field;
-      return (context) => applyFunction(record(context), field);
+      const describeMissing = getFieldError(expression);
+      return (context) => applyFunction(record(context), field, describeMissing);
     }
     case "Product": {
       const factors = expression.factors.map(child);
@@ -1492,7 +1842,11 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
     case "BoxAction":
     case "AngleAction": {
       const action = child(expression.action);
-      const unchanged = child(createUnchanged(expression.subscript, expression.location));
+      const unchanged = child({
+        kind: "Unchanged",
+        expression: expression.subscript,
+        location: expression.location,
+      });
       const isBox = expression.kind === "BoxAction";
       return (context) =>
         isBox
@@ -1506,21 +1860,19 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
     case "Label":
       return child(expression.body);
     case "Subexpression":
-      return throwing(
-        () =>
-          new TlaEvaluationError(
-            `The subexpression reference at ${describeLocation(expression)} does not name a subexpression`,
-          ),
-      );
+      return () => {
+        throw new TlaEvaluationError(
+          `The subexpression reference at ${describeLocation(expression)} does not name a subexpression`,
+        );
+      };
     case "Always":
     case "Eventually":
     case "WeakFairness":
     case "StrongFairness":
-      return throwing(
-        () =>
-          new TlaEvaluationError(
-            `TLC cannot evaluate a temporal formula in a state at ${describeLocation(expression)}`,
-          ),
-      );
+      return () => {
+        throw new TlaEvaluationError(
+          `TLC cannot evaluate a temporal formula in a state at ${describeLocation(expression)}`,
+        );
+      };
   }
 };