tla-ts 0.0.9 → 0.0.10-dev.28c823e4b

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (390) hide show
  1. package/README.md +29 -1
  2. package/dist/compile.cjs +23 -0
  3. package/dist/compile.js +23 -0
  4. package/dist/deciders.cjs +28 -28
  5. package/dist/deciders.js +43 -43
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +106 -10
  8. package/dist/index.d.ts +106 -10
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove-worker.cjs +1 -1
  13. package/dist/prove-worker.js +1 -1
  14. package/dist/prove.cjs +116 -36
  15. package/dist/prove.js +116 -36
  16. package/dist/run.cjs +143 -31
  17. package/dist/run.js +143 -31
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +129 -104
  21. package/dist/transfer.js +129 -104
  22. package/dist/worker.cjs +7 -7
  23. package/dist/worker.js +7 -7
  24. package/package.json +3 -1
  25. package/src/ast.ts +4 -23
  26. package/src/bags.ts +99 -102
  27. package/src/builtins.ts +40 -78
  28. package/src/bundled-modules.ts +1 -8
  29. package/src/check.ts +599 -388
  30. package/src/cli/options.ts +11 -6
  31. package/src/cli/run.ts +0 -2
  32. package/src/cli/runtime-invariants.ts +136 -0
  33. package/src/cli/shared.ts +18 -11
  34. package/src/cli/tlapm.ts +0 -12
  35. package/src/cli/tlc-arguments.ts +640 -0
  36. package/src/cli/tlc-usage.ts +361 -0
  37. package/src/cli/tlc.ts +538 -220
  38. package/src/cli/typescript.ts +23 -0
  39. package/src/cli/xml-exporter.ts +4 -16
  40. package/src/cli.ts +0 -1
  41. package/src/codegen.ts +191 -64
  42. package/src/config.ts +140 -109
  43. package/src/coverage.ts +837 -0
  44. package/src/dependencies.ts +6 -40
  45. package/src/dfid.ts +618 -0
  46. package/src/environment.ts +240 -118
  47. package/src/errors.ts +70 -55
  48. package/src/evaluate.ts +596 -339
  49. package/src/exit-codes.ts +37 -3
  50. package/src/fingerprints.ts +10 -10
  51. package/src/index.ts +3 -0
  52. package/src/instances.ts +79 -11
  53. package/src/java-overrides.ts +4 -19
  54. package/src/json-reader.ts +455 -0
  55. package/src/json.ts +255 -139
  56. package/src/levels.ts +8 -17
  57. package/src/lexer.ts +80 -100
  58. package/src/liveness-checker.ts +82 -119
  59. package/src/liveness.ts +112 -64
  60. package/src/obligations/action.ts +4 -28
  61. package/src/obligations/anonymize.ts +84 -80
  62. package/src/obligations/equality.ts +1 -1
  63. package/src/obligations/expression.ts +2 -19
  64. package/src/obligations/format.ts +1 -9
  65. package/src/obligations/generate.ts +1 -11
  66. package/src/obligations/index.ts +0 -11
  67. package/src/obligations/levels.ts +4 -8
  68. package/src/obligations/module.ts +1 -15
  69. package/src/obligations/normalize.ts +5 -24
  70. package/src/obligations/operators.ts +1 -2
  71. package/src/obligations/pragma.ts +1 -10
  72. package/src/obligations/printer.ts +47 -46
  73. package/src/obligations/proof.ts +1 -5
  74. package/src/obligations/regroup.ts +1 -4
  75. package/src/obligations/simplify.ts +3 -14
  76. package/src/obligations/source.ts +1 -21
  77. package/src/obligations/subexpression.ts +5 -11
  78. package/src/obligations/substitution.ts +1 -3
  79. package/src/obligations/temporal.ts +8 -14
  80. package/src/obligations/tuples.ts +3 -9
  81. package/src/parallel-worker.ts +29 -39
  82. package/src/parallel.ts +53 -44
  83. package/src/parser.ts +565 -282
  84. package/src/pcal/ast.ts +53 -86
  85. package/src/pcal/parse.ts +144 -219
  86. package/src/pcal/tokenize.ts +91 -131
  87. package/src/pcal/translate.ts +83 -130
  88. package/src/pcal/validate.ts +48 -68
  89. package/src/pretty-print.ts +7 -8
  90. package/src/prover/decide-pool.ts +5 -10
  91. package/src/prover/deciders.ts +0 -4
  92. package/src/prover/first-order.ts +0 -11
  93. package/src/prover/isabelle/decide.ts +0 -6
  94. package/src/prover/isabelle/encode.ts +11 -23
  95. package/src/prover/isabelle/isar/inner-syntax.ts +108 -114
  96. package/src/prover/isabelle/isar/method.ts +25 -38
  97. package/src/prover/isabelle/isar/proof.ts +1 -10
  98. package/src/prover/isabelle/isar/statement.ts +1 -6
  99. package/src/prover/isabelle/isar/theory.ts +15 -26
  100. package/src/prover/isabelle/isar/type-check.ts +11 -25
  101. package/src/prover/isabelle/provers/blast/blast.ts +10 -41
  102. package/src/prover/isabelle/provers/blast/branch.ts +1 -32
  103. package/src/prover/isabelle/provers/blast/prove.ts +1 -35
  104. package/src/prover/isabelle/provers/blast/rules.ts +6 -44
  105. package/src/prover/isabelle/provers/blast/state.ts +2 -28
  106. package/src/prover/isabelle/provers/blast/term.ts +9 -36
  107. package/src/prover/isabelle/provers/clasimp.ts +1 -13
  108. package/src/prover/isabelle/provers/classical.ts +14 -42
  109. package/src/prover/isabelle/provers/hypsubst.ts +11 -25
  110. package/src/prover/isabelle/pure/bicompose.ts +16 -13
  111. package/src/prover/isabelle/pure/consts.ts +1 -7
  112. package/src/prover/isabelle/pure/conv.ts +1 -9
  113. package/src/prover/isabelle/pure/drule.ts +24 -40
  114. package/src/prover/isabelle/pure/envir.ts +3 -52
  115. package/src/prover/isabelle/pure/goal.ts +1 -7
  116. package/src/prover/isabelle/pure/interrupt.ts +0 -5
  117. package/src/prover/isabelle/pure/list.ts +0 -3
  118. package/src/prover/isabelle/pure/logic.ts +1 -14
  119. package/src/prover/isabelle/pure/name.ts +2 -9
  120. package/src/prover/isabelle/pure/net.ts +3 -59
  121. package/src/prover/isabelle/pure/object-logic.ts +3 -10
  122. package/src/prover/isabelle/pure/pattern.ts +2 -19
  123. package/src/prover/isabelle/pure/raw-simplifier.ts +13 -49
  124. package/src/prover/isabelle/pure/rewriter.ts +26 -58
  125. package/src/prover/isabelle/pure/search.ts +3 -10
  126. package/src/prover/isabelle/pure/seq.ts +1 -10
  127. package/src/prover/isabelle/pure/simplifier.ts +4 -12
  128. package/src/prover/isabelle/pure/table.ts +1 -31
  129. package/src/prover/isabelle/pure/tactic.ts +12 -22
  130. package/src/prover/isabelle/pure/tactical.ts +6 -12
  131. package/src/prover/isabelle/pure/term-ord.ts +2 -6
  132. package/src/prover/isabelle/pure/term.ts +2 -43
  133. package/src/prover/isabelle/pure/thm.ts +13 -36
  134. package/src/prover/isabelle/pure/type.ts +2 -15
  135. package/src/prover/isabelle/pure/unify.ts +20 -30
  136. package/src/prover/isabelle/pure/variable.ts +3 -7
  137. package/src/prover/isabelle/tla/classical-setup.ts +9 -19
  138. package/src/prover/isabelle/tla/context.ts +8 -16
  139. package/src/prover/isabelle/tla/logic.ts +4 -11
  140. package/src/prover/isabelle/tla/simpdata.ts +46 -34
  141. package/src/prover/isabelle/tools/intuitionistic.ts +1 -10
  142. package/src/prover/ocaml.ts +0 -6
  143. package/src/prover/prep/action.ts +4 -36
  144. package/src/prover/prep/enabled-axioms.ts +12 -19
  145. package/src/prover/prep/fingerprint.ts +0 -16
  146. package/src/prover/prep/level-comparison.ts +8 -12
  147. package/src/prover/prep/md5.ts +0 -2
  148. package/src/prover/prep/methods.ts +9 -36
  149. package/src/prover/prep/normalize.ts +4 -28
  150. package/src/prover/prove-worker.ts +0 -2
  151. package/src/prover/prove.ts +0 -36
  152. package/src/prover/ptl/decide.ts +7 -12
  153. package/src/prover/ptl/encode.ts +14 -36
  154. package/src/prover/ptl/sat.ts +24 -32
  155. package/src/prover/ptl/tableau.ts +12 -26
  156. package/src/prover/smt/axioms.ts +0 -7
  157. package/src/prover/smt/context.ts +19 -26
  158. package/src/prover/smt/data.ts +51 -54
  159. package/src/prover/smt/encode.ts +14 -35
  160. package/src/prover/smt/extensionality.ts +0 -10
  161. package/src/prover/smt/flatten.ts +3 -22
  162. package/src/prover/smt/format.ts +5 -10
  163. package/src/prover/smt/instances.ts +0 -10
  164. package/src/prover/smt/rewrite.ts +66 -101
  165. package/src/prover/smt/solver/act-cache.ts +0 -15
  166. package/src/prover/smt/solver/arith-rewriter.ts +3 -48
  167. package/src/prover/smt/solver/array.ts +1 -3
  168. package/src/prover/smt/solver/asserted-formulas.ts +1 -43
  169. package/src/prover/smt/solver/ast-lt.ts +1 -11
  170. package/src/prover/smt/solver/ast-util.ts +1 -6
  171. package/src/prover/smt/solver/ast.ts +1 -143
  172. package/src/prover/smt/solver/auf-solver.ts +6 -39
  173. package/src/prover/smt/solver/case-split-queue.ts +1 -9
  174. package/src/prover/smt/solver/cg-table.ts +1 -18
  175. package/src/prover/smt/solver/clause.ts +1 -27
  176. package/src/prover/smt/solver/conflict-resolution.ts +0 -9
  177. package/src/prover/smt/solver/context.ts +4 -61
  178. package/src/prover/smt/solver/ctx-simplify.ts +14 -41
  179. package/src/prover/smt/solver/der.ts +2 -21
  180. package/src/prover/smt/solver/dyn-ack.ts +1 -11
  181. package/src/prover/smt/solver/e-matching.ts +3 -34
  182. package/src/prover/smt/solver/enode.ts +1 -21
  183. package/src/prover/smt/solver/expr-ref.ts +1 -5
  184. package/src/prover/smt/solver/expr-safe-replace.ts +0 -5
  185. package/src/prover/smt/solver/fingerprints.ts +1 -12
  186. package/src/prover/smt/solver/flat-literals.ts +1 -9
  187. package/src/prover/smt/solver/goal.ts +2 -14
  188. package/src/prover/smt/solver/hash.ts +0 -8
  189. package/src/prover/smt/solver/hashtable.ts +1 -12
  190. package/src/prover/smt/solver/internalizer.ts +6 -98
  191. package/src/prover/smt/solver/lbool.ts +1 -2
  192. package/src/prover/smt/solver/literal.ts +0 -3
  193. package/src/prover/smt/solver/lp/bound-propagator.ts +8 -26
  194. package/src/prover/smt/solver/lp/constraints.ts +2 -8
  195. package/src/prover/smt/solver/lp/containers.ts +12 -30
  196. package/src/prover/smt/solver/lp/core-solver.ts +10 -31
  197. package/src/prover/smt/solver/lp/cross-nested.ts +6 -20
  198. package/src/prover/smt/solver/lp/dep-intervals.ts +7 -22
  199. package/src/prover/smt/solver/lp/dependency.ts +1 -4
  200. package/src/prover/smt/solver/lp/dioph-eq.ts +12 -98
  201. package/src/prover/smt/solver/lp/explanation.ts +1 -6
  202. package/src/prover/smt/solver/lp/gomory.ts +9 -22
  203. package/src/prover/smt/solver/lp/hnf-cutter.ts +17 -23
  204. package/src/prover/smt/solver/lp/hnf.ts +11 -26
  205. package/src/prover/smt/solver/lp/int-cube.ts +15 -36
  206. package/src/prover/smt/solver/lp/int-solver.ts +4 -34
  207. package/src/prover/smt/solver/lp/lar-solver.ts +32 -81
  208. package/src/prover/smt/solver/lp/lar-term.ts +1 -5
  209. package/src/prover/smt/solver/lp/lp-settings.ts +1 -14
  210. package/src/prover/smt/solver/lp/maximize-term.ts +20 -45
  211. package/src/prover/smt/solver/lp/nex-creator.ts +5 -28
  212. package/src/prover/smt/solver/lp/nex.ts +1 -6
  213. package/src/prover/smt/solver/lp/nla-backoff.ts +1 -4
  214. package/src/prover/smt/solver/lp/nla-basics.ts +5 -30
  215. package/src/prover/smt/solver/lp/nla-core.ts +35 -130
  216. package/src/prover/smt/solver/lp/nla-divisions.ts +32 -42
  217. package/src/prover/smt/solver/lp/nla-emonics.ts +4 -21
  218. package/src/prover/smt/solver/lp/nla-factorization.ts +1 -4
  219. package/src/prover/smt/solver/lp/nla-grobner.ts +15 -69
  220. package/src/prover/smt/solver/lp/nla-horner.ts +3 -11
  221. package/src/prover/smt/solver/lp/nla-intervals.ts +2 -12
  222. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +16 -41
  223. package/src/prover/smt/solver/lp/nla-monotone.ts +2 -6
  224. package/src/prover/smt/solver/lp/nla-order.ts +2 -13
  225. package/src/prover/smt/solver/lp/nla-patcher.ts +4 -7
  226. package/src/prover/smt/solver/lp/nla-tangents.ts +1 -9
  227. package/src/prover/smt/solver/lp/nla-throttle.ts +1 -6
  228. package/src/prover/smt/solver/lp/nla-types.ts +1 -11
  229. package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -25
  230. package/src/prover/smt/solver/lp/nra-solver.ts +5 -52
  231. package/src/prover/smt/solver/lp/numeric-pair.ts +1 -4
  232. package/src/prover/smt/solver/lp/pdd-interval.ts +1 -3
  233. package/src/prover/smt/solver/lp/pdd-simplifier.ts +2 -14
  234. package/src/prover/smt/solver/lp/pdd-solver.ts +4 -33
  235. package/src/prover/smt/solver/lp/pdd.ts +7 -70
  236. package/src/prover/smt/solver/lp/random-updater.ts +1 -8
  237. package/src/prover/smt/solver/lp/static-matrix.ts +9 -19
  238. package/src/prover/smt/solver/lp/union-find.ts +1 -6
  239. package/src/prover/smt/solver/mam-compiler.ts +14 -56
  240. package/src/prover/smt/solver/mam-interpreter.ts +1 -21
  241. package/src/prover/smt/solver/maximize-ac-sharing.ts +2 -17
  242. package/src/prover/smt/solver/model-checker.ts +2 -36
  243. package/src/prover/smt/solver/model-evaluator.ts +3 -29
  244. package/src/prover/smt/solver/model-finder.ts +3 -15
  245. package/src/prover/smt/solver/model-generator.ts +1 -12
  246. package/src/prover/smt/solver/model-macro-solver.ts +12 -69
  247. package/src/prover/smt/solver/nlsat/algebraic.ts +55 -151
  248. package/src/prover/smt/solver/nlsat/atoms.ts +5 -19
  249. package/src/prover/smt/solver/nlsat/evaluator.ts +17 -22
  250. package/src/prover/smt/solver/nlsat/explain.ts +3 -47
  251. package/src/prover/smt/solver/nlsat/interval-set.ts +9 -50
  252. package/src/prover/smt/solver/nlsat/levelwise.ts +48 -129
  253. package/src/prover/smt/solver/nlsat/mpbq.ts +3 -14
  254. package/src/prover/smt/solver/nlsat/polynomial.ts +17 -156
  255. package/src/prover/smt/solver/nlsat/solver.ts +7 -67
  256. package/src/prover/smt/solver/nlsat/types.ts +1 -8
  257. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -44
  258. package/src/prover/smt/solver/nlsat/upolynomial.ts +11 -92
  259. package/src/prover/smt/solver/nnf.ts +3 -38
  260. package/src/prover/smt/solver/pattern-inference.ts +2 -15
  261. package/src/prover/smt/solver/poly-rewriter.ts +3 -23
  262. package/src/prover/smt/solver/propagate-values.ts +1 -10
  263. package/src/prover/smt/solver/proto-model.ts +3 -48
  264. package/src/prover/smt/solver/pull-quant.ts +1 -12
  265. package/src/prover/smt/solver/qe-lite-der.ts +1 -29
  266. package/src/prover/smt/solver/qe-lite-fm.ts +2 -25
  267. package/src/prover/smt/solver/qe-lite.ts +3 -33
  268. package/src/prover/smt/solver/qi-queue.ts +1 -16
  269. package/src/prover/smt/solver/quant-tactics.ts +5 -22
  270. package/src/prover/smt/solver/quantifier-analyzer.ts +17 -37
  271. package/src/prover/smt/solver/quantifier-manager.ts +1 -8
  272. package/src/prover/smt/solver/random-gen.ts +1 -2
  273. package/src/prover/smt/solver/rational.ts +1 -8
  274. package/src/prover/smt/solver/ref-vector.ts +1 -6
  275. package/src/prover/smt/solver/relevancy.ts +2 -15
  276. package/src/prover/smt/solver/rewriter-tpl.ts +3 -147
  277. package/src/prover/smt/solver/rewriter.ts +3 -85
  278. package/src/prover/smt/solver/rlimit.ts +2 -20
  279. package/src/prover/smt/solver/smtlib-parser.ts +2 -37
  280. package/src/prover/smt/solver/solver.ts +23 -34
  281. package/src/prover/smt/solver/sort.ts +1 -5
  282. package/src/prover/smt/solver/sticky-generations.ts +0 -5
  283. package/src/prover/smt/solver/theory-lra-axioms.ts +3 -24
  284. package/src/prover/smt/solver/theory-lra-bounds.ts +0 -5
  285. package/src/prover/smt/solver/theory-lra-final-check.ts +4 -22
  286. package/src/prover/smt/solver/theory-lra-internalize.ts +1 -27
  287. package/src/prover/smt/solver/theory-lra-model.ts +4 -19
  288. package/src/prover/smt/solver/theory-lra-propagate.ts +1 -15
  289. package/src/prover/smt/solver/theory-lra-state.ts +3 -8
  290. package/src/prover/smt/solver/theory-lra.ts +1 -8
  291. package/src/prover/smt/solver/var-subst.ts +2 -26
  292. package/src/prover/smt/table.ts +0 -8
  293. package/src/prover/tlapm/cache.ts +20 -25
  294. package/src/prover/tlapm/ocaml-marshal.ts +19 -21
  295. package/src/prover/tlapm/tlapm.ts +12 -17
  296. package/src/prover/verdict.ts +0 -2
  297. package/src/prover/zenon/check/check.ts +0 -9
  298. package/src/prover/zenon/check/definitions.ts +5 -15
  299. package/src/prover/zenon/check/equality.ts +0 -8
  300. package/src/prover/zenon/check/functions.ts +0 -4
  301. package/src/prover/zenon/check/keys.ts +0 -7
  302. package/src/prover/zenon/check/propositional.ts +0 -3
  303. package/src/prover/zenon/check/records.ts +0 -5
  304. package/src/prover/zenon/check/relations.ts +0 -13
  305. package/src/prover/zenon/check/rewrites.ts +0 -6
  306. package/src/prover/zenon/check/sets.ts +0 -3
  307. package/src/prover/zenon/check/terms.ts +0 -17
  308. package/src/prover/zenon/check/tla.ts +0 -6
  309. package/src/prover/zenon/decide.ts +0 -12
  310. package/src/prover/zenon/encode.ts +1 -8
  311. package/src/prover/zenon/eqrel.ts +0 -13
  312. package/src/prover/zenon/equality-rules.ts +0 -4
  313. package/src/prover/zenon/expr.ts +1 -26
  314. package/src/prover/zenon/index-table.ts +17 -38
  315. package/src/prover/zenon/isar-case.ts +9 -19
  316. package/src/prover/zenon/isar.ts +1 -29
  317. package/src/prover/zenon/limits.ts +0 -4
  318. package/src/prover/zenon/llproof.ts +0 -9
  319. package/src/prover/zenon/mltoll.ts +54 -76
  320. package/src/prover/zenon/node.ts +1 -11
  321. package/src/prover/zenon/ocaml.ts +1 -17
  322. package/src/prover/zenon/parse.ts +2 -7
  323. package/src/prover/zenon/phrase.ts +1 -11
  324. package/src/prover/zenon/proof.ts +0 -9
  325. package/src/prover/zenon/propositional-rules.ts +0 -5
  326. package/src/prover/zenon/rules.ts +2 -6
  327. package/src/prover/zenon/search.ts +1 -17
  328. package/src/prover/zenon/tla/functions.ts +57 -29
  329. package/src/prover/zenon/tla/llproof.ts +63 -70
  330. package/src/prover/zenon/tla/records.ts +56 -27
  331. package/src/prover/zenon/tla/rewrites.ts +12 -19
  332. package/src/prover/zenon/tla/sets.ts +68 -39
  333. package/src/prover/zenon/tla/terms.ts +0 -6
  334. package/src/prover/zenon/tla/tla.ts +59 -58
  335. package/src/randomization.ts +81 -35
  336. package/src/resolve.ts +12 -112
  337. package/src/runtime.ts +22 -22
  338. package/src/sany/builtins.ts +2 -5
  339. package/src/sany/generator.ts +149 -252
  340. package/src/sany/levels.ts +6 -34
  341. package/src/sany/lexer.ts +41 -61
  342. package/src/sany/linter.ts +1 -9
  343. package/src/sany/modules.ts +1 -5
  344. package/src/sany/nodes.ts +0 -31
  345. package/src/sany/parse-error.ts +39 -117
  346. package/src/sany/report.ts +29 -63
  347. package/src/sany/selectors.ts +15 -39
  348. package/src/sany/source.ts +1 -17
  349. package/src/sany/xml.ts +13 -63
  350. package/src/search.ts +495 -155
  351. package/src/simulate.ts +685 -0
  352. package/src/spec-description.ts +176 -69
  353. package/src/standard-definitions.ts +0 -4
  354. package/src/standard-modules.ts +254 -69
  355. package/src/state-graph.ts +50 -24
  356. package/src/subexpressions.ts +69 -52
  357. package/src/substitution-levels.ts +2 -3
  358. package/src/successors.ts +263 -94
  359. package/src/symmetry.ts +33 -25
  360. package/src/tableau.ts +27 -24
  361. package/src/tlc/fingerprint.ts +183 -67
  362. package/src/tlc/jar-data.ts +112 -6
  363. package/src/tlc/messages.ts +110 -44
  364. package/src/tlc/order.ts +37 -60
  365. package/src/tlc/random.ts +33 -45
  366. package/src/tlc/replay.ts +549 -217
  367. package/src/tlc/summary.ts +36 -47
  368. package/src/tlc/tlc-operators.ts +76 -41
  369. package/src/tlc/tlcext-operators.ts +139 -122
  370. package/src/tlc/trace-spec.ts +269 -0
  371. package/src/tlc/value-stream.ts +139 -0
  372. package/src/tlc/version.ts +1 -4
  373. package/src/transfer.ts +22 -25
  374. package/src/typescript/actions.ts +481 -0
  375. package/src/typescript/collections.ts +600 -0
  376. package/src/typescript/compile.ts +65 -0
  377. package/src/typescript/context.ts +94 -0
  378. package/src/typescript/emit.ts +121 -0
  379. package/src/typescript/expressions.ts +496 -0
  380. package/src/typescript/formula.ts +152 -0
  381. package/src/typescript/functions.ts +284 -0
  382. package/src/typescript/model.ts +163 -0
  383. package/src/typescript/names.ts +114 -0
  384. package/src/typescript/program.ts +48 -0
  385. package/src/typescript/properties.ts +139 -0
  386. package/src/typescript/scope.ts +112 -0
  387. package/src/typescript/steps.ts +165 -0
  388. package/src/typescript/types.ts +171 -0
  389. package/src/values.ts +780 -337
  390. package/src/worker.ts +7 -8
@@ -0,0 +1,496 @@
1
+ import ts from "@typescript/typescript6";
2
+ import {
3
+ translateArrayConstructor,
4
+ translateFunctionConstructor,
5
+ translateMethod,
6
+ translateNew,
7
+ translateSet,
8
+ translateSize,
9
+ } from "./collections";
10
+ import {
11
+ type Context,
12
+ getFunction,
13
+ getSymbol,
14
+ getTopLevelDeclaration,
15
+ isMethodCall,
16
+ share,
17
+ translateString,
18
+ } from "./context";
19
+ import { TlaTypeScriptError } from "../errors";
20
+ import { wrap, wrapEquated } from "./formula";
21
+ import { getDefinition, translateHelperCall, translateLocalCall } from "./functions";
22
+ import type { Scope } from "./scope";
23
+ import { getKind, isBooleanLike, isNumericKey } from "./types";
24
+
25
+ interface Field {
26
+ key: string;
27
+ value: string;
28
+ }
29
+
30
+ const BINARY_OPERATORS = new Map([
31
+ [ts.SyntaxKind.MinusToken, "-"],
32
+ [ts.SyntaxKind.AsteriskToken, "*"],
33
+ [ts.SyntaxKind.AsteriskAsteriskToken, "^"],
34
+ [ts.SyntaxKind.EqualsEqualsEqualsToken, "="],
35
+ [ts.SyntaxKind.ExclamationEqualsEqualsToken, "#"],
36
+ [ts.SyntaxKind.LessThanToken, "<"],
37
+ [ts.SyntaxKind.LessThanEqualsToken, "<="],
38
+ [ts.SyntaxKind.GreaterThanToken, ">"],
39
+ [ts.SyntaxKind.GreaterThanEqualsToken, ">="],
40
+ ]);
41
+
42
+ const ORDERING_OPERATORS = new Set([
43
+ ts.SyntaxKind.LessThanToken,
44
+ ts.SyntaxKind.LessThanEqualsToken,
45
+ ts.SyntaxKind.GreaterThanToken,
46
+ ts.SyntaxKind.GreaterThanEqualsToken,
47
+ ]);
48
+
49
+ const LOGICAL_OPERATORS = new Map([
50
+ [ts.SyntaxKind.AmpersandAmpersandToken, "/\\"],
51
+ [ts.SyntaxKind.BarBarToken, "\\/"],
52
+ ]);
53
+
54
+ export const translateKey = (node: ts.ElementAccessExpression, scope: Scope, context: Context) => {
55
+ const key = node.argumentExpression;
56
+ if (getKind(node.expression, context) !== "sequence") {
57
+ return translateExpression(key, scope, context);
58
+ }
59
+ return ts.isNumericLiteral(key)
60
+ ? String(Number(key.text) + 1)
61
+ : `${wrap(translateExpression(key, scope, context))} + 1`;
62
+ };
63
+
64
+ const translateArrayLiteral = (node: ts.ArrayLiteralExpression, scope: Scope, context: Context) => {
65
+ const parts = node.elements.reduce<(string | string[])[]>((result, element) => {
66
+ if (!ts.isSpreadElement(element)) {
67
+ const value = translateExpression(element, scope, context);
68
+ const last = result.at(-1);
69
+ return Array.isArray(last)
70
+ ? [...result.slice(0, -1), [...last, value]]
71
+ : [...result, [value]];
72
+ }
73
+ if (getKind(element.expression, context) !== "sequence") {
74
+ throw new TlaTypeScriptError(
75
+ "Sets have no order, so spread one only into every(), some(), filter(), map(), or find()",
76
+ element,
77
+ );
78
+ }
79
+ return [...result, translateExpression(element.expression, scope, context)];
80
+ }, []);
81
+ const sequences = parts.map((part) => (Array.isArray(part) ? `<<${part.join(", ")}>>` : part));
82
+ if (sequences.length === 0) return "<<>>";
83
+ return sequences.length === 1 ? sequences[0] : sequences.map(wrap).join(" \\o ");
84
+ };
85
+
86
+ const getField = (key: string) => (isNumericKey(key) ? `[${key}]` : `.${key}`);
87
+
88
+ const formatRecord = (fields: Field[]) =>
89
+ fields.every((field) => isNumericKey(field.key))
90
+ ? fields.map((field) => `(${field.key} :> ${field.value})`).join(" @@ ")
91
+ : `[${fields.map((field) => `${field.key} |-> ${field.value}`).join(", ")}]`;
92
+
93
+ const translateObjectLiteral = (
94
+ node: ts.ObjectLiteralExpression,
95
+ scope: Scope,
96
+ context: Context,
97
+ ) => {
98
+ const checker = context.checker;
99
+ const getKey = (property: ts.ObjectLiteralElementLike) =>
100
+ property.name === undefined || ts.isComputedPropertyName(property.name)
101
+ ? undefined
102
+ : property.name.getText().replace(/^["']|["']$/g, "");
103
+ const getValue = (property: ts.ObjectLiteralElementLike) => {
104
+ if (ts.isPropertyAssignment(property)) {
105
+ return translateExpression(property.initializer, scope, context);
106
+ }
107
+ if (ts.isShorthandPropertyAssignment(property)) {
108
+ return translateExpression(property.name, scope, context);
109
+ }
110
+ throw new TlaTypeScriptError("Unsupported object member", property);
111
+ };
112
+ const spreads = node.properties.filter(ts.isSpreadAssignment);
113
+ if (spreads.length === 0) {
114
+ if (node.properties.length === 0) {
115
+ throw new TlaTypeScriptError("TLA+ has no empty record, so use a Map", node);
116
+ }
117
+ return formatRecord(
118
+ node.properties.map((property) => {
119
+ const key = getKey(property);
120
+ if (key === undefined) {
121
+ throw new TlaTypeScriptError("Computed keys need a spread base", property);
122
+ }
123
+ return { key, value: getValue(property) };
124
+ }),
125
+ );
126
+ }
127
+ const base = node.properties[0];
128
+ const updates = node.properties.slice(1);
129
+ if (ts.isSpreadAssignment(base) && spreads.length === 1) {
130
+ const baseType = checker.getTypeAtLocation(base.expression);
131
+ const value = translateExpression(base.expression, scope, context);
132
+ if (updates.length === 0) return value;
133
+ const isUpdate = updates.every((property) => {
134
+ const key = getKey(property);
135
+ return key === undefined || baseType.getProperty(key) !== undefined;
136
+ });
137
+ if (isUpdate) {
138
+ const changes = updates.map((property) => {
139
+ const key = getKey(property);
140
+ if (key !== undefined) return `!${getField(key)} = ${wrapEquated(getValue(property))}`;
141
+ if (property.name === undefined || !ts.isComputedPropertyName(property.name)) {
142
+ throw new TlaTypeScriptError("Unsupported object member", property);
143
+ }
144
+ return `![${translateExpression(property.name.expression, scope, context)}] = ${wrapEquated(getValue(property))}`;
145
+ });
146
+ return `[${wrap(value)} EXCEPT ${changes.join(", ")}]`;
147
+ }
148
+ }
149
+ return formatRecord(
150
+ checker
151
+ .getTypeAtLocation(node)
152
+ .getProperties()
153
+ .map((property) => {
154
+ const key = property.name;
155
+ const member = node.properties.findLast((candidate) =>
156
+ ts.isSpreadAssignment(candidate)
157
+ ? checker.getTypeAtLocation(candidate.expression).getProperty(key) !== undefined
158
+ : getKey(candidate) === key,
159
+ );
160
+ if (
161
+ member === undefined ||
162
+ (!ts.isSpreadAssignment(member) && getKey(member) === undefined)
163
+ ) {
164
+ throw new TlaTypeScriptError(`Can't tell which value ${key} takes`, node);
165
+ }
166
+ return {
167
+ key,
168
+ value: ts.isSpreadAssignment(member)
169
+ ? `${wrap(translateExpression(member.expression, scope, context))}${getField(key)}`
170
+ : getValue(member),
171
+ };
172
+ }),
173
+ );
174
+ };
175
+
176
+ const translateMath = (node: ts.CallExpression, method: string, scope: Scope, context: Context) => {
177
+ const translate = (inner: ts.Expression) => wrap(translateExpression(inner, scope, context));
178
+ const argument = node.arguments[0];
179
+ if ((method === "floor" || method === "trunc") && node.arguments.length === 1) {
180
+ const division = ts.isParenthesizedExpression(argument) ? argument.expression : argument;
181
+ if (
182
+ !ts.isBinaryExpression(division) ||
183
+ division.operatorToken.kind !== ts.SyntaxKind.SlashToken
184
+ ) {
185
+ throw new TlaTypeScriptError(
186
+ `Math.${method} only takes a division, as in Math.${method}(a / b)`,
187
+ node,
188
+ );
189
+ }
190
+ const left = translate(division.left);
191
+ const right = translate(division.right);
192
+ if (method === "floor") return `${left} \\div ${right}`;
193
+ context.prelude.add("Quot");
194
+ return `Quot(${left}, ${right})`;
195
+ }
196
+ if (method === "abs" && node.arguments.length === 1) {
197
+ return share(
198
+ translate(argument),
199
+ "value",
200
+ context,
201
+ (value) => `IF ${value} < 0 THEN -${value} ELSE ${value}`,
202
+ );
203
+ }
204
+ if ((method === "min" || method === "max") && node.arguments.length > 0) {
205
+ const comparison = method === "min" ? "<=" : ">=";
206
+ if (node.arguments.length === 1 && ts.isSpreadElement(argument)) {
207
+ const set = wrap(translateSet(argument.expression, scope, context));
208
+ const candidate = context.names.getFresh("candidate");
209
+ const other = context.names.getFresh("other");
210
+ return `CHOOSE ${candidate} \\in ${set} : \\A ${other} \\in ${set} : ${candidate} ${comparison} ${other}`;
211
+ }
212
+ return node.arguments
213
+ .map(translate)
214
+ .reduce((result, inner) =>
215
+ share(result, "best", context, (best) =>
216
+ share(
217
+ inner,
218
+ "value",
219
+ context,
220
+ (value) => `IF ${best} ${comparison} ${value} THEN ${best} ELSE ${value}`,
221
+ ),
222
+ ),
223
+ );
224
+ }
225
+ throw new TlaTypeScriptError(`Unsupported call: Math.${method}`, node);
226
+ };
227
+
228
+ const translateCall = (
229
+ node: ts.CallExpression,
230
+ scope: Scope,
231
+ context: Context,
232
+ isDefined: boolean,
233
+ ) => {
234
+ const symbol = getSymbol(node.expression, context.checker);
235
+ const helper = getTopLevelDeclaration(symbol);
236
+ if (helper !== undefined) return translateHelperCall(helper, node, scope, context);
237
+ if (!isMethodCall(node)) {
238
+ const operator = symbol === undefined ? undefined : scope.bindings.get(symbol);
239
+ if (operator === undefined) return translateLocalCall(node, scope, context);
240
+ const values = node.arguments.map((argument) => translateExpression(argument, scope, context));
241
+ return `${operator}(${values.join(", ")})`;
242
+ }
243
+ const receiver = node.expression.expression;
244
+ const method = node.expression.name.text;
245
+ const global = ts.isIdentifier(receiver) ? receiver.text : undefined;
246
+ if (global === "Math") return translateMath(node, method, scope, context);
247
+ const constructed =
248
+ global === "Object" && method === "fromEntries"
249
+ ? translateFunctionConstructor(node.arguments[0], scope, context)
250
+ : translateArrayConstructor(node, scope, context);
251
+ return constructed ?? translateMethod(node, scope, context, isDefined);
252
+ };
253
+
254
+ const translateToString = (node: ts.Expression, scope: Scope, context: Context) => {
255
+ const value = translateExpression(node, scope, context);
256
+ return getKind(node, context) === "string" ? value : `ToString(${value})`;
257
+ };
258
+
259
+ const translateTemplate = (node: ts.TemplateExpression, scope: Scope, context: Context) => {
260
+ const parts = [
261
+ ...(node.head.text === "" ? [] : [JSON.stringify(node.head.text)]),
262
+ ...node.templateSpans.flatMap((span) => {
263
+ const value = translateToString(span.expression, scope, context);
264
+ return span.literal.text === "" ? [value] : [value, JSON.stringify(span.literal.text)];
265
+ }),
266
+ ];
267
+ return parts.length === 1 ? parts[0] : parts.map(wrap).join(" \\o ");
268
+ };
269
+
270
+ const translateBinary = (node: ts.BinaryExpression, scope: Scope, context: Context) => {
271
+ const kind = node.operatorToken.kind;
272
+ const translate = (inner: ts.Expression) => wrap(translateExpression(inner, scope, context));
273
+ const isString =
274
+ getKind(node.left, context) === "string" || getKind(node.right, context) === "string";
275
+ const logical = LOGICAL_OPERATORS.get(kind);
276
+ if (logical !== undefined) {
277
+ if (!isBooleanLike(node.left, context) || !isBooleanLike(node.right, context)) {
278
+ throw new TlaTypeScriptError(
279
+ `${node.operatorToken.getText()} needs booleans, so compare explicitly`,
280
+ node,
281
+ );
282
+ }
283
+ return `${translate(node.left)} ${logical} ${translate(node.right)}`;
284
+ }
285
+ if (kind === ts.SyntaxKind.PlusToken && isString) {
286
+ const left = wrap(translateToString(node.left, scope, context));
287
+ return `${left} \\o ${wrap(translateToString(node.right, scope, context))}`;
288
+ }
289
+ if (kind === ts.SyntaxKind.PlusToken) return `${translate(node.left)} + ${translate(node.right)}`;
290
+ if (kind === ts.SyntaxKind.PercentToken) {
291
+ context.prelude.add("Rem");
292
+ return `Rem(${translateExpression(node.left, scope, context)}, ${translateExpression(node.right, scope, context)})`;
293
+ }
294
+ if (kind === ts.SyntaxKind.QuestionQuestionToken) {
295
+ context.prelude.add("Null");
296
+ context.prelude.add("Undefined");
297
+ return share(
298
+ translate(node.left),
299
+ "value",
300
+ context,
301
+ (value) => `IF ${value} \\in {Null, Undefined} THEN ${translate(node.right)} ELSE ${value}`,
302
+ );
303
+ }
304
+ if (kind === ts.SyntaxKind.InKeyword) {
305
+ return `${translate(node.left)} \\in DOMAIN ${translate(node.right)}`;
306
+ }
307
+ if (kind === ts.SyntaxKind.SlashToken) {
308
+ throw new TlaTypeScriptError("Write division as Math.floor(a / b) or Math.trunc(a / b)", node);
309
+ }
310
+ if (ORDERING_OPERATORS.has(kind) && isString) {
311
+ throw new TlaTypeScriptError("TLA+ strings have no order, so compare them with === only", node);
312
+ }
313
+ const operator = BINARY_OPERATORS.get(kind);
314
+ if (operator === undefined) {
315
+ throw new TlaTypeScriptError(
316
+ `Unsupported operator: ${node.operatorToken.getText()}`,
317
+ node.operatorToken,
318
+ );
319
+ }
320
+ return `${translate(node.left)} ${operator} ${translate(node.right)}`;
321
+ };
322
+
323
+ const getPreviousVariable = (name: string, node: ts.Node, context: Context) => {
324
+ const variable = [...context.variables].find((entry) => entry[0].name === name);
325
+ if (variable === undefined) throw new TlaTypeScriptError(`Unknown variable: ${name}`, node);
326
+ return variable[1];
327
+ };
328
+
329
+ const translateEnumMember = (node: ts.Node, symbol: ts.Symbol, context: Context) => {
330
+ const declaration = symbol.valueDeclaration;
331
+ const value =
332
+ declaration !== undefined && ts.isEnumMember(declaration)
333
+ ? context.checker.getConstantValue(declaration)
334
+ : undefined;
335
+ if (typeof value === "string") return translateString(value, context);
336
+ if (typeof value === "number" && Number.isInteger(value)) return String(value);
337
+ throw new TlaTypeScriptError("Unsupported enum member", node);
338
+ };
339
+
340
+ const translateDeclared = (
341
+ node: ts.Node,
342
+ symbol: ts.Symbol | undefined,
343
+ scope: Scope,
344
+ context: Context,
345
+ ) => {
346
+ if (symbol !== undefined && symbol.flags & ts.SymbolFlags.EnumMember) {
347
+ return translateEnumMember(node, symbol, context);
348
+ }
349
+ const declaration = getTopLevelDeclaration(symbol);
350
+ if (declaration === undefined) return undefined;
351
+ return getFunction(declaration) === undefined
352
+ ? translateHelperCall(declaration, undefined, scope, context)
353
+ : getDefinition(declaration, context).name;
354
+ };
355
+
356
+ const translateIdentifier = (node: ts.Identifier, scope: Scope, context: Context) => {
357
+ if (node.text === "undefined") {
358
+ context.prelude.add("Undefined");
359
+ return "Undefined";
360
+ }
361
+ const symbol = getSymbol(node, context.checker);
362
+ const binding = symbol === undefined ? undefined : scope.bindings.get(symbol);
363
+ if (binding !== undefined) return binding;
364
+ if (symbol !== undefined && symbol === scope.previous) {
365
+ return formatRecord(
366
+ context.checker
367
+ .getTypeAtLocation(node)
368
+ .getProperties()
369
+ .map((property) => ({
370
+ key: property.name,
371
+ value: getPreviousVariable(property.name, node, context),
372
+ })),
373
+ );
374
+ }
375
+ const declared = translateDeclared(node, symbol, scope, context);
376
+ if (declared !== undefined) return declared;
377
+ if (symbol !== undefined && context.variables.has(symbol)) {
378
+ throw new TlaTypeScriptError(`${node.text} can't be read here`, node);
379
+ }
380
+ throw new TlaTypeScriptError(`Unknown name: ${node.text}`, node);
381
+ };
382
+
383
+ const translatePropertyAccess = (
384
+ node: ts.PropertyAccessExpression,
385
+ scope: Scope,
386
+ context: Context,
387
+ ) => {
388
+ if (node.questionDotToken !== undefined) {
389
+ throw new TlaTypeScriptError("Optional chaining isn't supported", node);
390
+ }
391
+ const declared = translateDeclared(node, getSymbol(node, context.checker), scope, context);
392
+ if (declared !== undefined) return declared;
393
+ const receiver = node.expression;
394
+ const name = node.name.text;
395
+ if (
396
+ scope.previous !== undefined &&
397
+ ts.isIdentifier(receiver) &&
398
+ getSymbol(receiver, context.checker) === scope.previous
399
+ ) {
400
+ return getPreviousVariable(name, node, context);
401
+ }
402
+ const size =
403
+ name === "length" || name === "size" ? translateSize(receiver, scope, context) : undefined;
404
+ return size ?? `${wrap(translateExpression(receiver, scope, context))}.${name}`;
405
+ };
406
+
407
+ const translateElementAccess = (
408
+ node: ts.ElementAccessExpression,
409
+ scope: Scope,
410
+ context: Context,
411
+ ) => {
412
+ const value = wrap(translateExpression(node.expression, scope, context));
413
+ return `${value}[${translateKey(node, scope, context)}]`;
414
+ };
415
+
416
+ export const translateCondition = (node: ts.Expression, scope: Scope, context: Context) => {
417
+ if (!isBooleanLike(node, context)) {
418
+ throw new TlaTypeScriptError("Conditions must be booleans, so compare explicitly", node);
419
+ }
420
+ return translateExpression(node, scope, context);
421
+ };
422
+
423
+ export const translateNegatedCondition = (
424
+ node: ts.Expression,
425
+ scope: Scope,
426
+ context: Context,
427
+ ): string => {
428
+ if (ts.isParenthesizedExpression(node)) {
429
+ return translateNegatedCondition(node.expression, scope, context);
430
+ }
431
+ if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.ExclamationToken) {
432
+ return translateCondition(node.operand, scope, context);
433
+ }
434
+ if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
435
+ const left = translateNegatedCondition(node.left, scope, context);
436
+ const right = translateNegatedCondition(node.right, scope, context);
437
+ return `${wrap(left)} /\\ ${wrap(right)}`;
438
+ }
439
+ return `~${wrap(translateCondition(node, scope, context))}`;
440
+ };
441
+
442
+ export const translateExpression = (
443
+ node: ts.Expression,
444
+ scope: Scope,
445
+ context: Context,
446
+ isDefined = false,
447
+ ): string => {
448
+ if (
449
+ ts.isParenthesizedExpression(node) ||
450
+ ts.isAsExpression(node) ||
451
+ ts.isSatisfiesExpression(node) ||
452
+ ts.isTypeAssertionExpression(node)
453
+ ) {
454
+ return translateExpression(node.expression, scope, context, isDefined);
455
+ }
456
+ if (ts.isNonNullExpression(node)) {
457
+ return translateExpression(node.expression, scope, context, true);
458
+ }
459
+ if (ts.isNumericLiteral(node)) {
460
+ if (!Number.isInteger(Number(node.text))) {
461
+ throw new TlaTypeScriptError(`Only integers are supported: ${node.text}`, node);
462
+ }
463
+ return String(Number(node.text));
464
+ }
465
+ if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
466
+ return translateString(node.text, context);
467
+ }
468
+ if (ts.isTemplateExpression(node)) return translateTemplate(node, scope, context);
469
+ if (node.kind === ts.SyntaxKind.TrueKeyword) return "TRUE";
470
+ if (node.kind === ts.SyntaxKind.FalseKeyword) return "FALSE";
471
+ if (node.kind === ts.SyntaxKind.NullKeyword) {
472
+ context.prelude.add("Null");
473
+ return "Null";
474
+ }
475
+ if (ts.isIdentifier(node)) return translateIdentifier(node, scope, context);
476
+ if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.ExclamationToken) {
477
+ if (!isBooleanLike(node.operand, context)) {
478
+ throw new TlaTypeScriptError("! needs a boolean, so compare explicitly", node);
479
+ }
480
+ return `~${wrap(translateExpression(node.operand, scope, context))}`;
481
+ }
482
+ if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken) {
483
+ return `-${wrap(translateExpression(node.operand, scope, context))}`;
484
+ }
485
+ if (ts.isBinaryExpression(node)) return translateBinary(node, scope, context);
486
+ if (ts.isConditionalExpression(node)) {
487
+ return `IF ${translateCondition(node.condition, scope, context)} THEN ${translateExpression(node.whenTrue, scope, context)} ELSE ${translateExpression(node.whenFalse, scope, context)}`;
488
+ }
489
+ if (ts.isArrayLiteralExpression(node)) return translateArrayLiteral(node, scope, context);
490
+ if (ts.isObjectLiteralExpression(node)) return translateObjectLiteral(node, scope, context);
491
+ if (ts.isPropertyAccessExpression(node)) return translatePropertyAccess(node, scope, context);
492
+ if (ts.isElementAccessExpression(node)) return translateElementAccess(node, scope, context);
493
+ if (ts.isCallExpression(node)) return translateCall(node, scope, context, isDefined);
494
+ if (ts.isNewExpression(node)) return translateNew(node, scope, context);
495
+ throw new TlaTypeScriptError(`Unsupported expression: ${node.getText()}`, node);
496
+ };
@@ -0,0 +1,152 @@
1
+ export type Formula = TextFormula | DisabledFormula | AndFormula | IfFormula | LetFormula;
2
+
3
+ interface TextFormula {
4
+ kind: "text";
5
+ text: string;
6
+ }
7
+
8
+ interface DisabledFormula {
9
+ kind: "disabled";
10
+ }
11
+
12
+ interface AndFormula {
13
+ kind: "and";
14
+ items: Formula[];
15
+ }
16
+
17
+ interface IfFormula {
18
+ kind: "if";
19
+ condition: string;
20
+ whenTrue: Formula;
21
+ whenFalse: Formula;
22
+ }
23
+
24
+ interface LetFormula {
25
+ kind: "let";
26
+ definitions: string[];
27
+ body: Formula;
28
+ }
29
+
30
+ export const DISABLED: Formula = { kind: "disabled" };
31
+
32
+ export const createText = (value: string): Formula => ({ kind: "text", text: value });
33
+
34
+ export const and = (items: Formula[]): Formula => {
35
+ const flattened = items.flatMap((item) => (item.kind === "and" ? item.items : [item]));
36
+ if (flattened.some((item) => item.kind === "disabled")) return DISABLED;
37
+ const kept = flattened.filter((item) => item.kind !== "text" || item.text !== "TRUE");
38
+ if (kept.length === 0) return createText("TRUE");
39
+ return kept.length === 1 ? kept[0] : { kind: "and", items: kept };
40
+ };
41
+
42
+ export const ifThenElse = (
43
+ condition: string,
44
+ whenTrue: Formula,
45
+ whenFalse: Formula,
46
+ negated = `~${wrap(condition)}`,
47
+ ): Formula => {
48
+ if (whenTrue.kind === "disabled" && whenFalse.kind === "disabled") return DISABLED;
49
+ if (whenFalse.kind === "disabled") return and([createText(condition), whenTrue]);
50
+ if (whenTrue.kind === "disabled") return and([createText(negated), whenFalse]);
51
+ return { kind: "if", condition, whenTrue, whenFalse };
52
+ };
53
+
54
+ export const letIn = (definitions: string[], body: Formula): Formula => {
55
+ if (body.kind === "disabled" || definitions.length === 0) return body;
56
+ if (body.kind === "let") return letIn([...definitions, ...body.definitions], body.body);
57
+ return { kind: "let", definitions, body };
58
+ };
59
+
60
+ const prefixLines = (lines: string[], first: string, rest: string) =>
61
+ lines.map((line, index) => `${index === 0 ? first : rest}${line}`);
62
+
63
+ const renderLines = (formula: Formula): string[] => {
64
+ if (formula.kind === "disabled") return ["FALSE"];
65
+ if (formula.kind === "text") return formula.text.split("\n");
66
+ if (formula.kind === "and") {
67
+ return formula.items.flatMap((item) => prefixLines(renderLines(item), "/\\ ", " "));
68
+ }
69
+ if (formula.kind === "if") {
70
+ return [
71
+ ...prefixLines(formula.condition.split("\n"), "IF ", " "),
72
+ ...prefixLines(renderLines(formula.whenTrue), "THEN ", " "),
73
+ ...prefixLines(renderLines(formula.whenFalse), "ELSE ", " "),
74
+ ];
75
+ }
76
+ return [
77
+ ...formula.definitions.flatMap((definition, index) =>
78
+ prefixLines(definition.split("\n"), index === 0 ? "LET " : " ", " "),
79
+ ),
80
+ ...prefixLines(renderLines(formula.body), "IN ", " "),
81
+ ];
82
+ };
83
+
84
+ export const render = (formula: Formula) => renderLines(formula).join("\n");
85
+
86
+ const OPENING = new Set(["(", "[", "{"]);
87
+ const CLOSING = new Set([")", "]", "}"]);
88
+
89
+ interface Scan {
90
+ depth: number;
91
+ isQuoted: boolean;
92
+ isEscaped: boolean;
93
+ isSkipped: boolean;
94
+ surface: string;
95
+ }
96
+
97
+ const getSurface = (expression: string) =>
98
+ [...expression].reduce<Scan>(
99
+ (scan, character, index) => {
100
+ if (scan.isSkipped) return { ...scan, isSkipped: false };
101
+ if (scan.isQuoted) {
102
+ return {
103
+ ...scan,
104
+ isQuoted: scan.isEscaped || character !== '"',
105
+ isEscaped: !scan.isEscaped && character === "\\",
106
+ };
107
+ }
108
+ const pair = expression.slice(index, index + 2);
109
+ if (pair === "<<") return { ...scan, depth: scan.depth + 1, isSkipped: true };
110
+ if (pair === ">>" && scan.depth > 0) {
111
+ return { ...scan, depth: scan.depth - 1, isSkipped: true };
112
+ }
113
+ if (character === '"') return { ...scan, isQuoted: true };
114
+ if (OPENING.has(character)) return { ...scan, depth: scan.depth + 1 };
115
+ if (CLOSING.has(character)) return { ...scan, depth: scan.depth - 1 };
116
+ return scan.depth === 0 ? { ...scan, surface: scan.surface + character } : scan;
117
+ },
118
+ { depth: 0, isQuoted: false, isEscaped: false, isSkipped: false, surface: "" },
119
+ ).surface;
120
+
121
+ const isAtomic = (expression: string) =>
122
+ expression !== "" &&
123
+ !/^[~-]/.test(expression) &&
124
+ !expression.includes("\n") &&
125
+ !getSurface(expression).includes(" ");
126
+
127
+ export const wrap = (expression: string) => (isAtomic(expression) ? expression : `(${expression})`);
128
+
129
+ const LOOSE_OPERATORS = [
130
+ " = ",
131
+ " # ",
132
+ " < ",
133
+ " > ",
134
+ " <= ",
135
+ " >= ",
136
+ " \\in ",
137
+ " \\notin ",
138
+ " \\subseteq ",
139
+ " /\\ ",
140
+ " \\/ ",
141
+ " => ",
142
+ " ~> ",
143
+ ];
144
+
145
+ export const wrapEquated = (expression: string) =>
146
+ expression.startsWith("~") ||
147
+ LOOSE_OPERATORS.some((operator) => getSurface(expression).includes(operator))
148
+ ? `(${expression})`
149
+ : expression;
150
+
151
+ export const indent = (expression: string, prefix: string) =>
152
+ expression.split("\n").join(`\n${prefix}`);