arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/ex/emit.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""Эмиттер Elixir. Модель — модуль `LawModel` с чистым состоянием таблиц: правила
+принимают db и возвращают {grew, db}; порядок строк — порядок добавления.
+Сборки нет: `elixir runner.exs` компилирует файлы при запуске."""
+import json
+import shutil
+import sys
+from pathlib import Path
+
+SUPPORTED_PLAN = "law-backend-plan/0.7"
+OPS = {"add": "add", "sub": "sub", "mul": "mul", "div": "divide", "mod": "modulo"}
+FNS = {"round": "round", "min": "min", "max": "max", "abs": "absolute", "pow": "pow"}
+
+
+def check_plan(plan: dict) -> None:
+    v = plan.get("planVersion")
+    if v != SUPPORTED_PLAN:
+        raise ValueError(f"версия плана не поддержана эмиттером: {v!r} (поддержана {SUPPORTED_PLAN})")
+
+
+def estr(s: str) -> str:
+    return json.dumps(s, ensure_ascii=False).replace("#{", "\\#{")
+
+
+def term(t: dict) -> str:
+    k = t["k"]
+    if k == "var":
+        return f'elem(r{t["row"]}, {t["col"]})'
+    if k == "lit":
+        if t["t"] == "money":
+            return f'LawRT.money({estr(t["v"])}, {estr(t["cur"])})'
+        if t["t"] == "dec":
+            return f'LawRT.dec({estr(t["v"])})'
+        if t["t"] == "date":
+            return f'LawRT.date({estr(t["v"])})'
+        if t["t"] == "enum":
+            return f'LawRT.sym({estr(t["v"])})'
+        return f'{{:text, {estr(t["v"])}}}'
+    if k == "bin":
+        return f'LawRT.{OPS[t["op"]]}({term(t["l"])}, {term(t["r"])})'
+    if k == "call":
+        args = t["args"]
+        if t["fn"] == "round":
+            return f'LawRT.round({term(args[0])}, {term(args[1])}, {estr(args[2]["v"])})'
+        return f'LawRT.{FNS[t["fn"]]}(' + ", ".join(term(a) for a in args) + ')'
+    raise AssertionError(k)
+
+
+def emit(plan: dict) -> str:
+    check_plan(plan)
+    L = ["defmodule LawModel do"]
+    L.append("  def new, do: %{tables: %{" + ", ".join(f"{estr(t['pred'])} => []" for t in plan["tables"]) + "}, seen: %{}}")
+    L.append("  def rows(db, pred), do: Map.get(db.tables, pred, [])")
+    L.append("  # Объявленные типы параметров: раннер сверяет с ними аргументы дела (§189).")
+    for t in plan["tables"]:
+        L.append(f"  def params({estr(t['pred'])}), do: [" + ", ".join(estr(p) for p in t["params"]) + "]")
+    L.append("  def params(_), do: nil")
+    L.append("  # Константы §54: тип для проверки §189 и значение для разыменования аргументов дела.")
+    for cid, c in plan["consts"].items():
+        L.append(f"  def consts({estr(cid)}), do: {{{estr(c['type'])}, {term(c['term'])}}}")
+    L.append("  def consts(_), do: nil")
+    L.append("  # Наследование сущностей: подтип подходит параметру базового типа.")
+    for sub, base in plan["bases"].items():
+        L.append(f"  def base({estr(sub)}), do: {estr(base)}")
+    L.append("  def base(_), do: nil")
+    L.append("  # Ключи отношений §45.1: позиции столбцов каждого ключа.")
+    for t in plan["tables"]:
+        if t["keys"]:
+            L.append(f"  def keys({estr(t['pred'])}), do: [" + ", ".join("[" + ", ".join(str(i) for i in k) + "]" for k in t["keys"]) + "]")
+    L.append("  def keys(_), do: []")
+    L.append("")
+    L.append("  # KEY_CONFLICT §45.1/§196: группы строк одной таблицы с одинаковой проекцией на ключ; строки уникальны по ключу строки, поэтому группа из двух и более строк — различные accepted-кортежи. Считается после насыщения.")
+    L.append("  def key_conflicts(db) do")
+    L.append("    Enum.sum(for pred <- Map.keys(db.tables), key <- keys(pred) do")
+    L.append("      rows(db, pred)")
+    L.append("      |> Enum.frequencies_by(fn row -> LawRT.key(Enum.map(key, &elem(row, &1))) end)")
+    L.append("      |> Map.values()")
+    L.append("      |> Enum.count(&(&1 > 1))")
+    L.append("    end)")
+    L.append("  end")
+    L.append("")
+    L.append("  def key_conflict_predicates(db), do: for pred <- Map.keys(db.tables), Enum.any?(keys(pred), &(key_conflicts_for(db, pred, &1) > 0)), do: pred")
+    L.append("  defp key_conflicts_for(db, pred, key), do: rows(db, pred) |> Enum.frequencies_by(fn row -> LawRT.key(Enum.map(key, &elem(row, &1))) end) |> Map.values() |> Enum.count(&(&1 > 1))")
+    readers: dict[str, set[str]] = {}
+    for rule in plan["rules"]:
+        for atom in rule.get("atoms") or []:
+            readers.setdefault(atom["pred"], set()).add(rule["head"]["pred"])
+        for check in rule.get("checks") or []:
+            readers.setdefault(check["pred"], set()).add(rule["head"]["pred"])
+    for pred, heads in sorted(readers.items()):
+        L.append(f"  def key_readers({estr(pred)}), do: [" + ", ".join(estr(head) for head in sorted(heads)) + "]")
+    L.append("  def key_readers(_), do: []")
+    L.append("")
+    L.append("  def add_row(db, pred, row) do")
+    L.append("    k = {pred, LawRT.key(Tuple.to_list(row))}")
+    L.append("    if Map.has_key?(db.seen, k) do")
+    L.append("      {false, db}")
+    L.append("    else")
+    L.append("      {true, %{db | tables: Map.update!(db.tables, pred, &(&1 ++ [row])), seen: Map.put(db.seen, k, true)}}")
+    L.append("    end")
+    L.append("  end")
+    L.append("")
+    L.append("  def register(db, pred, row), do: elem(add_row(db, pred, row), 1)")
+    L.append("")
+    for r in plan["rules"]:
+        L.append(f"  # {r['id']}")
+        L.append(f"  defp rule_{r['name']}(db0) do")
+        pre = []
+        if r["window"]:
+            if r["window"].get("start"):
+                pre.append(f"LawRT.legal_time() < {estr(r['window']['start'])}")
+            if r["window"].get("end"):
+                pre.append(f"LawRT.legal_time() >= {estr(r['window']['end'])}")
+        ind = "    "
+        if pre:
+            L.append(f"{ind}if {' or '.join(pre)} do")
+            L.append(f"{ind}  {{false, db0}}")
+            L.append(f"{ind}else")
+            ind += "  "
+        n = len(r["atoms"])
+        for i, a in enumerate(r["atoms"]):
+            gprev = f"g{i - 1}" if i > 0 else "false"
+            L.append(f"{ind}Enum.reduce(rows(db{i}, {estr(a['pred'])}), {{{gprev}, db{i}}}, fn r{i}, {{g{i}, db{i + 1}}} ->")
+            ind += "  "
+        checks = [f'LawRT.cmp(elem(r{ai}, {aj}), "eq", elem(r{bi}, {bj}))'
+                  for (ai, aj, _at), (bi, bj, _bt) in r["joins"]]
+        checks += [f'LawRT.eq(elem(r{f["row"]}, {f["col"]}), {term(f["term"])})' for f in r["filters"]]
+        checks += [f'LawRT.cmp({term(g["l"])}, {estr(g["op"])}, {term(g["r"])})' for g in r["guards"]]
+        gname = f"g{n - 1}" if n else "false"
+        dbname = f"db{n}"
+        args = ", ".join(term(a) for a in r["head"]["args"])
+        add = f"case add_row({dbname}, {estr(r['head']['pred'])}, {{{args}}}) do {{true, d}} -> {{true, d}}; {{false, d}} -> {{{gname}, d}} end"
+        if checks:
+            L.append(f"{ind}cond do")
+            for c in checks:
+                L.append(f"{ind}  not {c} -> {{{gname}, {dbname}}}")
+            L.append(f"{ind}  true -> {add}")
+            L.append(f"{ind}end")
+        else:
+            L.append(f"{ind}{add}")
+        for _ in range(n):
+            ind = ind[:-2]
+            L.append(f"{ind}end)")
+        if pre:
+            ind = ind[:-2]
+            L.append(f"{ind}end")
+        L.append("  end")
+        L.append("")
+    names = [r["name"] for r in plan["rules"]]
+    L.append("  def saturate(db0) do")
+    if names:
+        L.append("    {grew, db} = Enum.reduce([" + ", ".join(f"&rule_{n}/1" for n in names) + "], {false, db0}, fn rule, {g, d} -> {g2, d2} = rule.(d); {g or g2, d2} end)")
+        L.append("    if grew, do: saturate(db), else: db")
+    else:
+        L.append("    db0")
+    L.append("  end")
+    L.append("")
+    L.append("  def package_facts(db0) do")
+    if plan["facts"]:
+        L.append("    Enum.reduce([")
+        L.append(",\n".join(f"      {{{estr(f['pred'])}, {{" + ", ".join(term(a) for a in f["args"]) + "}}" for f in plan["facts"]))
+        L.append("    ], db0, fn {p, row}, db -> register(db, p, row) end)")
+    else:
+        L.append("    db0")
+    L.append("  end")
+    L.append("end")
+    return "\n".join(L) + "\n"
+
+
+# --- дескриптор цели ---------------------------------------------------------
+HERE = Path(__file__).resolve().parent
+EXT = "ex"
+MODEL = "model.ex"
+MAINS = {"runner": "runner.exs", "cert": "cert.exs"}
+
+
+def available():
+    ex = shutil.which("elixir")
+    return (True, ex) if ex else (False, "нет elixir в PATH")
+
+
+def layout(proj, main: str) -> list:
+    proj = Path(proj)
+    proj.mkdir(parents=True, exist_ok=True)
+    out = []
+    for name in ("runtime.ex", MAINS[main]):
+        shutil.copyfile(HERE / name, proj / name)
+        out.append(proj / name)
+    return out
+
+
+def build(proj):
+    return None
+
+
+def run(proj, main: str):
+    return ["elixir", str(Path(proj) / MAINS[main])], None
+
+
+if __name__ == "__main__":
+    sys.path.insert(0, str(HERE.parents[1]))
+    import plan as P
+    ir = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
+    Path(sys.argv[2]).write_text(emit(P.build_plan(ir)), encoding="utf-8")

arxo_codegen/targets/ex/runner.exs

@@ -0,0 +1,124 @@
+# Раннер Elixir-бэкенда: тот же вход и тот же ответ, что у runner.py.
+#
+# Протокол выхода общий для всех целей: ответ — JSON и код 0; названный отказ
+# среза — JSON {"refused": текст} и код 3; любой другой код — крах.
+Code.require_file("runtime.ex", __DIR__)
+Code.require_file("model.ex", __DIR__)
+
+defmodule LawRunner do
+  defp text(v) when is_binary(v), do: v
+  defp text(v) when is_integer(v), do: Integer.to_string(v)
+  defp text(nil), do: ""
+  defp text(v), do: JSON.encode!(v)
+
+  def arg(a) do
+    case a["kind"] do
+      "entity_ref" -> {:text, a["id"]}
+      "const_ref" ->
+        # §54: разыменование предшествует исполнению; член перечисления §38 либо
+        # имя без объявления остаётся идентичностью, как в ключе атома оракула.
+        case LawModel.consts(a["id"]) do
+          nil -> LawRT.sym(a["id"])
+          {_, v} -> v
+        end
+      "value" ->
+        t = get_in(a, ["type", "name"])
+        v = text(a["value"])
+        case t do
+          "urn:law:std#Money" -> LawRT.money(v, a["currency"])
+          "urn:law:std#Decimal" -> LawRT.dec(v)
+          "urn:law:std#Integer" -> LawRT.dec(v)
+          "urn:law:std#Text" -> {:text, v}
+          "urn:law:std#Date" -> LawRT.date(v)
+          _ -> LawRT.refuse(["аргумент вне среза раннера: ", text(t)])
+        end
+      k -> LawRT.refuse(["аргумент вне среза раннера: ", text(k)])
+    end
+  end
+
+  # Тип аргумента, если известен: у value — из узла, у const_ref — из объявления
+  # константы; entity_ref типа не несёт (как у оракула).
+  def arg_type(a) do
+    case a["kind"] do
+      "value" -> get_in(a, ["type", "name"])
+      "const_ref" -> (case LawModel.consts(a["id"]) do nil -> nil; {t, _} -> t end)
+      _ -> nil
+    end
+  end
+
+  # Совпадение типа с наследованием сущностей вверх от фактического.
+  def conforms(actual, expected, seen \\ %{})
+  def conforms(nil, _, _), do: false
+  def conforms(expected, expected, _), do: true
+  def conforms(cur, expected, seen) do
+    if Map.has_key?(seen, cur), do: false, else: conforms(LawModel.base(cur), expected, Map.put(seen, cur, true))
+  end
+
+  def typed(params, args) do
+    length(params) == length(args) and
+      Enum.all?(Enum.zip(params, args), fn {e, a} -> (case arg_type(a) do nil -> true; t -> conforms(t, e) end) end)
+  end
+
+  def key_conflict_blocks(db, predicate), do: key_closure(LawModel.key_conflict_predicates(db), predicate, MapSet.new())
+  defp key_closure([], predicate, seen), do: MapSet.member?(seen, predicate)
+  defp key_closure([source | waiting], predicate, seen) do
+    if MapSet.member?(seen, source), do: key_closure(waiting, predicate, seen),
+      else: key_closure(waiting ++ LawModel.key_readers(source), predicate, MapSet.put(seen, source))
+  end
+
+  def run(case_path, query_path) do
+    kase = JSON.decode!(File.read!(case_path))
+    query = JSON.decode!(File.read!(query_path))
+    LawRT.set_legal_time(text(get_in(kase, ["context", "legalTime"])))
+    db0 = LawModel.package_facts(LawModel.new())
+    {db1, issues} =
+      Enum.reduce(kase["assertions"] || [], {db0, []}, fn a, {db, iss} ->
+        lit = a["literal"]
+        if lit["polarity"] != "positive", do: LawRT.refuse("§113: отрицательный факт вне L0-среза")
+        pred = lit["predicate"]
+        args = lit["args"] || []
+        case LawModel.params(pred) do
+          nil -> {db, iss}
+          params ->
+            # Арность и типы аргументов утверждения против сигнатуры §189 (E-0046).
+            if typed(params, args),
+              do: {LawModel.register(db, pred, List.to_tuple(Enum.map(args, &arg/1))), iss},
+              else: {db, iss ++ ["TYPE_ERROR"]}
+        end
+      end)
+    db2 = LawModel.saturate(db1)
+    issues = issues ++ List.duplicate("KEY_CONFLICT", LawModel.key_conflicts(db2))
+    if query["kind"] != "truth", do: LawRT.refuse(["вид запроса вне среза раннера: ", text(query["kind"])])
+    qlit = query["literal"]
+    qargs = qlit["args"] || []
+    # Ключ атома у оракула §208 включает ТИП значения: несогласованный запрос
+    # атома не находит — NEITHER без issue.
+    hit =
+      case LawModel.params(qlit["predicate"]) do
+        nil -> false
+        qparams ->
+          if typed(qparams, qargs) do
+            want = Enum.map(qargs, &arg/1)
+            Enum.any?(LawModel.rows(db2, qlit["predicate"]), fn row ->
+              r = Tuple.to_list(row)
+              length(r) == length(want) and Enum.all?(Enum.zip(r, want), fn {v, w} -> LawRT.eq(v, w) end)
+            end)
+          else
+            false
+          end
+      end
+    # Открытый мир: отсутствие строки — это NEITHER, а не FALSE_ONLY.
+    evaluation = if key_conflict_blocks(db2, qlit["predicate"]), do: "NON_EXECUTABLE", else: "COMPUTED"
+    IO.puts(JSON.encode!(%{"queryId" => query["queryId"], "truthStatus" => (if hit, do: "TRUE_ONLY", else: "NEITHER"),
+                           "evaluationStatus" => evaluation, "issues" => issues}))
+  end
+end
+
+[case_path, query_path] = System.argv()
+try do
+  LawRunner.run(case_path, query_path)
+catch
+  {:refused, msg} ->
+    IO.puts(JSON.encode!(%{"refused" => msg}))
+    System.halt(3)
+end

arxo_codegen/targets/ex/runtime.ex

@@ -0,0 +1,227 @@
+# Рантайм L0 для Elixir. Тот же контракт, что у runtime.py: точная десятичная
+# арифметика §58 на встроенных целых, деньги с валютой, названный режим
+# округления, календарный день, член перечисления. Отказ — throw({:refused, msg}),
+# любая другая ошибка — крах.
+defmodule LawRT do
+  import Kernel, except: [max: 2, min: 2]
+  # Значения: {:dec, u, s} | {:money, u, s, cur} | {:text, t} | {:date, d} | {:sym, id}.
+  def refuse(msg), do: throw({:refused, IO.iodata_to_binary(msg)})
+
+  defp p10(n), do: Integer.pow(10, n)
+
+  def dec(lit) when is_binary(lit) do
+    {i, f} = case String.split(lit, ".", parts: 2) do [a, b] -> {a, b}; [a] -> {a, ""} end
+    neg = String.starts_with?(i, "-")
+    digits = (if neg, do: String.slice(i, 1..-1//1), else: i) <> f
+    u = String.to_integer(digits)
+    {:dec, (if neg, do: -u, else: u), String.length(f)}
+  end
+
+  def money(lit, cur), do: (({:dec, u, s} = dec(lit)); {:money, u, s, cur})
+  def date(lit), do: {:date, lit}
+  def sym(id), do: {:sym, id}
+
+  # --- виды -------------------------------------------------------------------
+  defp num({:dec, u, s}), do: {u, s, nil}
+  defp num({:money, u, s, c}), do: {u, s, c}
+  defp num(_), do: nil
+
+  defp money?({:money, _, _, _}), do: true
+  defp money?(_), do: false
+
+  # §48/§58: сложение, вычитание, min/max требуют совпадения видов; у денег — и валюты.
+  defp same!(a, b, op) do
+    case {num(a), num(b)} do
+      {{_, _, ca}, {_, _, cb}} when is_nil(ca) == is_nil(cb) ->
+        if ca != nil and ca != cb, do: refuse(["§58: разные валюты: ", op])
+      _ -> refuse(["§58: виды операндов не совпадают: ", op])
+    end
+  end
+
+  defp pair(a, b) do
+    {au, as, _} = num(a); {bu, bs, _} = num(b)
+    s = Kernel.max(as, bs)
+    {au * p10(s - as), bu * p10(s - bs), s}
+  end
+
+  defp mk(u, s, {:money, _, _, c}), do: {:money, u, s, c}
+  defp mk(u, s, _), do: {:dec, u, s}
+
+  # Целое значение: дробная часть нулевая (защита в глубину под статикой плана).
+  defp integral({:dec, u, s}), do: (if rem(u, p10(s)) == 0, do: {:ok, div(u, p10(s))}, else: nil)
+  defp integral(_), do: nil
+
+  # --- арифметика §58 ---------------------------------------------------------
+  def add(a, b), do: (same!(a, b, "add"); ({x, y, s} = pair(a, b)); mk(x + y, s, a))
+  def sub(a, b), do: (same!(a, b, "sub"); ({x, y, s} = pair(a, b)); mk(x - y, s, a))
+
+  # Правило скаляра §49: безразмерное масштабирует размерное; масштаб результата —
+  # сумма масштабов. Два размерных не перемножаются.
+  def mul(a, b) do
+    case {num(a), num(b)} do
+      {{au, as, ca}, {bu, bs, cb}} ->
+        if ca != nil and cb != nil, do: refuse("§58: произведение двух размерных величин не определено")
+        mk(au * bu, as + bs, (if ca != nil, do: a, else: b))
+      _ -> refuse("§58: виды операндов не совпадают: mul")
+    end
+  end
+
+  defp strip(d, p, n), do: (if rem(d, p) == 0, do: strip(div(d, p), p, n + 1), else: {d, n})
+
+  # Точное десятичное частное num/den при 10-гладком знаменателе (§18), иначе nil.
+  defp exact(num0, den0) do
+    g = case Integer.gcd(num0, den0) do 0 -> 1; x -> x end
+    {num1, den1} = {div(num0, g), div(den0, g)}
+    {num, den} = if den1 < 0, do: {-num1, -den1}, else: {num1, den1}
+    {d2, twos} = strip(den, 2, 0)
+    {d5, fives} = strip(d2, 5, 0)
+    if d5 == 1 do
+      k = Kernel.max(twos, fives)
+      {num * Integer.pow(2, k - twos) * Integer.pow(5, k - fives), k}
+    end
+  end
+
+  # Таблица делимых §58 в срезе: Decimal/Decimal, Money/Decimal, Money/Money одной
+  # валюты. Integer/Integer даёт Rational — вне среза, отвергается планом статически.
+  def divide(a, b) do
+    case {num(a), num(b)} do
+      {{au, as, ca}, {bu, bs, cb}} ->
+        if bu == 0, do: refuse("деление на ноль — evaluation error (§58)")
+        like = case {ca, cb} do
+          {nil, nil} -> nil
+          {_, nil} -> a
+          {nil, _} -> refuse("§58: деление вне таблицы делимых")
+          {c, c} -> nil
+          _ -> refuse("CURRENCY_MISMATCH: §58 делит Money на Money только при тождественной валюте")
+        end
+        case exact(au * p10(bs), bu * p10(as)) do
+          nil when like != nil -> refuse("INEXACT_DIVISION: округление только явной политикой (§50/§18)")
+          nil -> refuse("§58: частное не 10-гладкое — Rational вне среза")
+          {u, s} when is_nil(like) -> {:dec, u, s}
+          {u, s} -> mk(u, s, like)
+        end
+      _ -> refuse("§58: деление вне таблицы делимых")
+    end
+  end
+
+  # Евклидов остаток §58: 0 <= r < |b| при любых знаках операндов.
+  def modulo(a, b) do
+    case {integral(a), integral(b)} do
+      {{:ok, _}, {:ok, 0}} -> refuse("остаток от деления на ноль — evaluation error (§58)")
+      {{:ok, x}, {:ok, y}} -> {:dec, Integer.mod(x, abs(y)), 0}
+      _ -> refuse("§58: mod определён только для Integer")
+    end
+  end
+
+  def min(a, b), do: (same!(a, b, "min"); ({x, y, _} = pair(a, b)); (if x <= y, do: a, else: b))
+  def max(a, b), do: (same!(a, b, "max"); ({x, y, _} = pair(a, b)); (if x >= y, do: a, else: b))
+
+  def absolute(v) do
+    case num(v) do
+      {u, s, _} -> mk(abs(u), s, v)
+      nil -> refuse("§58: abs — не числовой вид")
+    end
+  end
+
+  # §58 (E-0075): только Integer pow Integer; порядок проверок — знак, предел,
+  # вычисление, диапазон — часть контракта.
+  def pow(base, exp) do
+    case {integral(base), integral(exp)} do
+      {{:ok, x}, {:ok, e}} ->
+        if e < 0, do: refuse("§58: pow — показатель отрицателен")
+        if e > 4096, do: refuse("RESOURCE_LIMIT: pow — показатель превышает 4096")
+        r = Integer.pow(x, e)
+        if r < -Integer.pow(2, 63) or r > Integer.pow(2, 63) - 1, do: refuse("RESOURCE_LIMIT: pow — результат вне 64-битного диапазона")
+        {:dec, r, 0}
+      _ -> refuse("§58: pow определён только для Integer")
+    end
+  end
+
+  def round(m, digits, mode) do
+    if mode != "HALF_UP", do: refuse(["§50: режим округления не реализован: ", mode])
+    case num(m) do
+      nil -> refuse("§50: round — не числовой вид")
+      {mu, ms, _} ->
+        n = case num(digits) do {du, ds, _} -> div(du, p10(ds)); nil -> 0 end
+        if ms <= n do
+          mk(mu * p10(n - ms), n, m)
+        else
+          drop = p10(ms - n)
+          a = abs(mu); q = div(a, drop); r = rem(a, drop)
+          up = if r * 2 >= drop, do: q + 1, else: q
+          mk((if mu < 0, do: -up, else: up), n, m)
+        end
+    end
+  end
+
+  # --- сравнение и равенство ---------------------------------------------------
+  defp ordered("lt", x, y), do: x < y
+  defp ordered("le", x, y), do: x <= y
+  defp ordered("gt", x, y), do: x > y
+  defp ordered("ge", x, y), do: x >= y
+  defp ordered("eq", x, y), do: x == y
+  defp ordered("ne", x, y), do: x != y
+  defp ordered(op, _, _), do: refuse(["сравнение вне среза рантайма: ", op])
+
+  def cmp(a, op, b) do
+    case {a, b} do
+      {{:sym, x}, {:sym, y}} -> (case op do "eq" -> x == y; "ne" -> x != y; _ -> refuse("§57: вид enum не упорядочен") end)
+      {{:sym, _}, _} -> (case op do "eq" -> false; "ne" -> true; _ -> refuse("§57: вид enum не упорядочен") end)
+      {_, {:sym, _}} -> (case op do "eq" -> false; "ne" -> true; _ -> refuse("§57: вид enum не упорядочен") end)
+      {{:date, x}, {:date, y}} -> ordered(op, x, y)
+      {{:date, _}, _} -> (case op do "eq" -> false; "ne" -> true; _ -> refuse("§57: Date сравнивается только с Date") end)
+      {_, {:date, _}} -> (case op do "eq" -> false; "ne" -> true; _ -> refuse("§57: Date сравнивается только с Date") end)
+      {{:text, x}, {:text, y}} -> (case op do "eq" -> x == y; "ne" -> x != y; _ -> refuse(["порядок на Text вне среза рантайма: ", op]) end)
+      {{:text, _}, _} -> (case op do "eq" -> false; "ne" -> true; _ -> refuse(["порядок на Text вне среза рантайма: ", op]) end)
+      {_, {:text, _}} -> (case op do "eq" -> false; "ne" -> true; _ -> refuse(["порядок на Text вне среза рантайма: ", op]) end)
+      _ ->
+        if money?(a) != money?(b), do: refuse("§49: сравнение денег с безразмерным")
+        if money?(a) and elem(a, 3) != elem(b, 3), do: refuse("§49: разные валюты")
+        {x, y, _} = pair(a, b)
+        ordered(op, x, y)
+    end
+  end
+
+  def eq({:sym, x}, {:sym, y}), do: x == y
+  def eq({:sym, _}, _), do: false
+  def eq(_, {:sym, _}), do: false
+  def eq({:date, x}, {:date, y}), do: x == y
+  def eq({:date, _}, _), do: false
+  def eq(_, {:date, _}), do: false
+  def eq({:text, x}, {:text, y}), do: x == y
+  def eq({:text, _}, _), do: false
+  def eq(_, {:text, _}), do: false
+  def eq(a, b) do
+    if money?(a) != money?(b) or (money?(a) and elem(a, 3) != elem(b, 3)) do
+      false
+    else
+      {x, y, _} = pair(a, b)
+      x == y
+    end
+  end
+
+  defp norm(u, s) when s > 0 and rem(u, 10) == 0, do: norm(div(u, 10), s - 1)
+  defp norm(u, s), do: "#{u}e-#{s}"
+
+  # Разделитель и экран внутри текста экранируются: иначе ["a|e:b","c"] и
+  # ["a","b|e:c"] склеивались в один ключ, и второй факт терялся.
+  defp esc(t), do: t |> String.replace("\\", "\\\\") |> String.replace("|", "\\|")
+
+  defp cell({:text, t}), do: "e:" <> esc(t)
+  defp cell({:date, d}), do: "t:" <> d
+  defp cell({:sym, i}), do: "c:" <> esc(i)
+  defp cell({:money, u, s, c}), do: "m:" <> c <> ":" <> norm(u, s)
+  defp cell({:dec, u, s}), do: "d:" <> norm(u, s)
+
+  def key(row), do: Enum.map_join(row, "|", &cell/1)
+
+  def set_legal_time(t), do: Process.put(:law_legal_time, t)
+
+  def legal_time do
+    case Process.get(:law_legal_time) do
+      nil -> refuse("legalTime не подан делом")
+      "" -> refuse("legalTime не подан делом")
+      t -> t
+    end
+  end
+end