arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/rb/cert.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+# Харнесс сертификации рантайма: исполняет runtime-cert.json и печатает,
+# что получилось. Ожидания сверяют ворота, харнесс их не читает.
+require "json"
+require_relative "runtime"
+
+def lit(x)
+  return x if x.is_a?(String)
+  return RT.dec(x["dec"]) if x.key?("dec")
+  return RT.money(x["money"], x["cur"]) if x.key?("money")
+  return x["text"] if x.key?("text")
+  return RT.date(x["date"]) if x.key?("date")
+  return RT.sym(x["sym"]) if x.key?("sym")
+  return x["row"].map { |v| lit(v) } if x.key?("row")
+  raise "литерал фикстуры: #{x}"
+end
+
+# Отображение с ЯВНЫМ масштабом: 2.00 и 2 — разные записи одного значения.
+def digits(u, s)
+  neg = u.negative?
+  body = u.abs.to_s.rjust(s + 1, "0")
+  text = s.zero? ? body : body[0...-s] + "." + body[-s..]
+  (neg ? "-" : "") + text
+end
+
+def render(v)
+  case v
+  when nil, true, false, String then v
+  when RT::Money then digits(v.u, v.s) + " " + v.cur
+  when RT::Date then v.v
+  when RT::Sym then v.id
+  else digits(v.u, v.s)
+  end
+end
+
+def run(c)
+  a = c["args"].map { |x| lit(x) }
+  case c["op"]
+  when "dec" then RT.dec(a[0])
+  when "money" then RT.money(a[0], a[1])
+  when "date" then RT.date(a[0])
+  when "sym" then RT.sym(a[0])
+  when "mul" then RT.mul(a[0], a[1])
+  when "add" then RT.add(a[0], a[1])
+  when "sub" then RT.sub(a[0], a[1])
+  when "div" then RT.div(a[0], a[1])
+  when "mod" then RT.mod(a[0], a[1])
+  when "min" then RT.min(a[0], a[1])
+  when "max" then RT.max(a[0], a[1])
+  when "abs" then RT.abs(a[0])
+  when "pow" then RT.pow(a[0], a[1])
+  when "round" then RT.round(a[0], a[1], a[2])
+  when "cmp" then RT.cmp(a[0], a[1], a[2])
+  when "eq" then RT.eq(a[0], a[1])
+  when "keyEq" then RT.key(a[0]) == RT.key(a[1])
+  when "legalTime" then RT.legal_time
+  when "setLegalTime"
+    RT.set_legal_time(a[0])
+    nil
+  else raise "неизвестная операция фикстуры: #{c['op']}"
+  end
+end
+
+fixture = JSON.parse(File.read(ARGV[0], encoding: "utf-8"))
+out = fixture["cases"].map do |c|
+  got = begin
+    render(run(c))
+  rescue RT::Refused => e
+    {"refused" => e.message}
+  end
+  {"id" => c["id"], "got" => got}
+end
+puts JSON.generate(out)

arxo_codegen/targets/rb/emit.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""Эмиттер Ruby. Тот же план, другой синтаксис и тот же контракт рантайма."""
+import json
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+# Версия плана, которую этот эмиттер умеет печатать. Другая версия — отказ:
+# незнакомое поле плана печаталось бы молча, а это другой ответ, не меньший.
+SUPPORTED_PLAN = "law-backend-plan/0.7"
+
+
+def check_plan(plan: dict) -> None:
+    v = plan.get("planVersion")
+    if v != SUPPORTED_PLAN:
+        raise ValueError(f"версия плана не поддержана эмиттером: {v!r} (поддержана {SUPPORTED_PLAN})")
+
+
+def term(t: dict) -> str:
+    k = t["k"]
+    if k == "var":
+        return f'r{t["row"]}[{t["col"]}]'
+    if k == "lit":
+        if t["t"] == "money":
+            return f'RT.money("{t["v"]}", "{t["cur"]}")'
+        if t["t"] == "dec":
+            return f'RT.dec("{t["v"]}")'
+        if t["t"] == "date":
+            return f'RT.date("{t["v"]}")'
+        if t["t"] == "enum":
+            return f'RT.sym("{t["v"]}")'
+        return json.dumps(t["v"], ensure_ascii=False)
+    if k == "bin":
+        return f'RT.{t["op"]}({term(t["l"])}, {term(t["r"])})'
+    if k == "call":
+        return f'RT.{t["fn"]}(' + ", ".join(term(a) for a in t["args"]) + ')'
+    raise AssertionError(k)
+
+
+def emit(plan: dict) -> str:
+    check_plan(plan)
+    L = ['require_relative "runtime"', "", "module Model", "  TABLES = {"]
+    for t in plan["tables"]:
+        L.append(f'    {json.dumps(t["pred"])} => [],')
+    L.append("  }.freeze")
+    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"])
+    L.append("  # E-0210/E-0242: forward readers of a keyed relation.")
+    L.append("  KEY_READERS = " + repr({key: sorted(value) for key, value in sorted(readers.items())}).replace(": ", " => ") + ".freeze")
+    L.append("  # Объявленные типы параметров: раннер сверяет с ними аргументы дела (§189).")
+    L.append("  PARAMS = {")
+    for t in plan["tables"]:
+        L.append(f'    {json.dumps(t["pred"])} => {json.dumps(t["params"], ensure_ascii=False)},')
+    L.append("  }.freeze")
+    L.append("  # Константы §54: тип для проверки §189 и значение для разыменования аргументов дела.")
+    L.append("  CONSTS = {")
+    for cid, c in plan["consts"].items():
+        L.append(f'    {json.dumps(cid)} => [{json.dumps(c["type"])}, {term(c["term"])}],')
+    L.append("  }.freeze")
+    L.append("  # Наследование сущностей: подтип подходит параметру базового типа.")
+    L.append("  BASES = " + json.dumps(plan["bases"], ensure_ascii=False).replace(": ", " => ") + ".freeze")
+    L.append("  # Ключи отношений §45.1: позиции столбцов каждого ключа.")
+    L.append("  KEYS = {")
+    for t in plan["tables"]:
+        if t["keys"]:
+            L.append(f'    {json.dumps(t["pred"])} => {json.dumps(t["keys"])},')
+    L.append("  }.freeze")
+    L.append("  @seen = {}")
+    L.append("")
+    L.append("  def self.add_row(urn, row)")
+    L.append("    k = [urn, RT.key(row)]")
+    L.append("    return false if @seen[k]")
+    L.append("    @seen[k] = true")
+    L.append("    TABLES[urn] << row")
+    L.append("    true")
+    L.append("  end")
+    L.append("")
+    for r in plan["rules"]:
+        L.append(f'  # {r["id"]}')
+        L.append(f'  def self.rule_{r["name"]}')
+        L.append("    grew = false")
+        if r["window"]:
+            if r["window"].get("start"):
+                L.append(f'    return false if RT.legal_time < "{r["window"]["start"]}"')
+            if r["window"].get("end"):
+                L.append(f'    return false if RT.legal_time >= "{r["window"]["end"]}"')
+        ind = "    "
+        for i, a in enumerate(r["atoms"]):
+            L.append(f'{ind}TABLES[{json.dumps(a["pred"])}].dup.each do |r{i}|')
+            ind += "  "
+        for (ai, aj, _at), (bi, bj, _bt) in r["joins"]:
+            L.append(f'{ind}next unless RT.cmp(r{ai}[{aj}], "eq", r{bi}[{bj}])')
+        for f in r["filters"]:
+            L.append(f'{ind}next unless RT.eq(r{f["row"]}[{f["col"]}], {term(f["term"])})')
+        for g in r["guards"]:
+            L.append(f'{ind}next unless RT.cmp({term(g["l"])}, "{g["op"]}", {term(g["r"])})')
+        args = ", ".join(term(a) for a in r["head"]["args"])
+        L.append(f'{ind}grew = true if add_row({json.dumps(r["head"]["pred"])}, [{args}])')
+        for _ in r["atoms"]:
+            ind = ind[:-2]
+            L.append(ind + "end")
+        L.append("    grew")
+        L.append("  end")
+        L.append("")
+    names = [r["name"] for r in plan["rules"]]
+    L.append("  def self.saturate")
+    L.append("    grew = true")
+    L.append("    while grew")
+    if names:
+        L.append("      grew = [" + ", ".join(f"rule_{n}" for n in names) + "].any?")
+    else:
+        L.append("      grew = false")
+    L.append("    end")
+    L.append("  end")
+    L.append("")
+    L.append("  def self.register(urn, row)")
+    L.append("    add_row(urn, row)")
+    L.append("  end")
+    L.append("")
+    L.append("  # KEY_CONFLICT §45.1/§196: группы строк одной таблицы с одинаковой проекцией на ключ; строки уникальны по ключу строки, поэтому группа из двух и более строк — различные accepted-кортежи. Считается после насыщения.")
+    L.append("  def self.key_conflicts")
+    L.append("    n = 0")
+    L.append("    KEYS.each do |urn, keys|")
+    L.append("      keys.each do |key|")
+    L.append("        groups = Hash.new(0)")
+    L.append("        TABLES[urn].each { |row| groups[RT.key(key.map { |i| row[i] })] += 1 }")
+    L.append("        n += groups.values.count { |c| c > 1 }")
+    L.append("      end")
+    L.append("    end")
+    L.append("    n")
+    L.append("  end")
+    L.append("")
+    L.append("  def self.key_conflict_predicates")
+    L.append("    out = {}")
+    L.append("    KEYS.each do |urn, keys|")
+    L.append("      keys.each do |key|")
+    L.append("        groups = Hash.new(0)")
+    L.append("        TABLES[urn].each { |row| groups[RT.key(key.map { |i| row[i] })] += 1 }")
+    L.append("        out[urn] = true if groups.values.any? { |c| c > 1 }")
+    L.append("      end")
+    L.append("    end")
+    L.append("    out.keys")
+    L.append("  end")
+    L.append("")
+    for f in plan["facts"]:
+        L.append(f'  add_row({json.dumps(f["pred"])}, [' + ", ".join(term(a) for a in f["args"]) + '])')
+    L.append("end")
+    return "\n".join(L) + "\n"
+
+
+# --- дескриптор цели ---------------------------------------------------------
+HERE = Path(__file__).resolve().parent
+EXT = "rb"
+MODEL = "model.rb"
+
+
+def available():
+    rb = shutil.which("ruby")
+    if not rb:
+        return False, "нет ruby в PATH"
+    try:
+        version = subprocess.check_output([rb, "--version"], text=True, stderr=subprocess.STDOUT).strip()
+    except (OSError, subprocess.CalledProcessError) as exc:
+        return False, f"ruby не запускается: {exc}"
+    match = re.search(r"\bruby\s+(\d+)\.(\d+)", version, flags=re.IGNORECASE)
+    if match is None:
+        return False, f"не прочитана версия ruby: {version[:120]}"
+    if tuple(map(int, match.groups())) < (3, 0):
+        return False, f"Ruby >= 3.0 нужен для синтаксиса рантайма (найден {match.group(0)})"
+    return True, f"{rb} ({match.group(0)})"
+
+MAINS = {"runner": "runner.rb", "cert": "cert.rb"}
+
+
+def layout(proj, main: str) -> list:
+    proj = Path(proj)
+    proj.mkdir(parents=True, exist_ok=True)
+    out = []
+    for name in ("runtime.rb", 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 ["ruby", 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/rb/runner.rb

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+# Раннер Ruby-бэкенда: тот же вход и тот же ответ, что у runner.py.
+#
+# Протокол выхода общий для всех целей: ответ — JSON и код 0; названный отказ
+# среза — JSON {"refused": текст} и код 3, текст побайтово одинаков между
+# целями; любой другой ненулевой код — крах, который ворота валят.
+require "json"
+require_relative "runtime"
+require_relative "model"
+
+ISSUES = []
+
+def arg(a)
+  kind = a["kind"]
+  return a["id"] if kind == "entity_ref"
+  if kind == "const_ref"
+    # §54: разыменование предшествует исполнению; член перечисления §38 либо
+    # имя без объявления остаётся идентичностью, как в ключе атома оракула.
+    c = Model::CONSTS[a["id"]]
+    return c.nil? ? RT.sym(a["id"].to_s) : c[1]
+  end
+  raise RT::Refused, "аргумент вне среза раннера: #{kind}" unless kind == "value"
+  t = (a["type"] || {})["name"]
+  case t
+  when "urn:law:std#Money" then RT.money(a["value"].to_s, a["currency"])
+  when "urn:law:std#Decimal", "urn:law:std#Integer" then RT.dec(a["value"].to_s)
+  when "urn:law:std#Text" then a["value"].to_s
+  when "urn:law:std#Date" then RT.date(a["value"].to_s)
+  else raise RT::Refused, "аргумент вне среза раннера: #{t}"
+  end
+end
+
+# Тип аргумента, если известен: у value — из узла, у const_ref — из объявления
+# константы; entity_ref типа не несёт (как у оракула).
+def arg_type(a)
+  return (a["type"] || {})["name"] if a["kind"] == "value"
+  if a["kind"] == "const_ref"
+    c = Model::CONSTS[a["id"]]
+    return c.nil? ? nil : c[0]
+  end
+  nil
+end
+
+# Совпадение типа с наследованием сущностей вверх от фактического.
+def conforms(actual, expected)
+  seen = {}
+  cur = actual
+  while !cur.nil? && !seen[cur]
+    return true if cur == expected
+    seen[cur] = true
+    cur = Model::BASES[cur]
+  end
+  false
+end
+
+# Арность и типы аргументов утверждения против сигнатуры §189 (E-0046).
+def well_typed(lit)
+  params = Model::PARAMS[lit["predicate"]]
+  return true if params.nil?
+  args = lit["args"] || []
+  if args.length != params.length
+    ISSUES << "TYPE_ERROR"
+    return false
+  end
+  params.zip(args).each do |expected, a|
+    actual = arg_type(a)
+    next if actual.nil? || conforms(actual, expected)
+    ISSUES << "TYPE_ERROR"
+    return false
+  end
+  true
+end
+
+# Ключ атома у оракула §208 включает ТИП значения: несогласованный запрос
+# атома не находит — NEITHER без issue.
+def query_typed(lit)
+  params = Model::PARAMS[lit["predicate"]]
+  return false if params.nil?
+  args = lit["args"] || []
+  return false if args.length != params.length
+  params.zip(args).all? { |expected, a| arg_type(a).nil? || conforms(arg_type(a), expected) }
+end
+
+def key_conflict_blocks(predicate)
+  # E-0210/E-0242: only the forward closure of a conflicted relation blocks.
+  tainted = {}
+  Model.key_conflict_predicates.each { |source| tainted[source] = true }
+  waiting = tainted.keys
+  until waiting.empty?
+    source = waiting.pop
+    (Model::KEY_READERS[source] || []).each do |consumer|
+      next if tainted[consumer]
+      tainted[consumer] = true
+      waiting << consumer
+    end
+  end
+  tainted.key?(predicate)
+end
+
+def main
+  kase = JSON.parse(File.read(ARGV[0], encoding: "utf-8"))
+  query = JSON.parse(File.read(ARGV[1], encoding: "utf-8"))
+  RT.set_legal_time(((kase["context"] || {})["legalTime"] || "").to_s)
+  kase["assertions"].each do |a|
+    lit = a["literal"]
+    raise RT::Refused, "§113: отрицательный факт вне L0-среза" unless lit["polarity"] == "positive"
+    next unless well_typed(lit)
+    next unless Model::PARAMS.key?(lit["predicate"])
+    Model.register(lit["predicate"], lit["args"].map { |x| arg(x) })
+  end
+  Model.saturate
+  Model.key_conflicts.times { ISSUES << "KEY_CONFLICT" }
+  raise RT::Refused, "вид запроса вне среза раннера: #{query['kind']}" unless query["kind"] == "truth"
+  hit = false
+  if query_typed(query["literal"])
+    want = query["literal"]["args"].map { |x| arg(x) }
+    rows = Model::TABLES[query["literal"]["predicate"]] || []
+    hit = rows.any? { |r| r.length == want.length && r.each_with_index.all? { |v, i| RT.eq(v, want[i]) } }
+  end
+  # Открытый мир: отсутствие строки — это NEITHER, а не FALSE_ONLY.
+  puts JSON.generate({"queryId" => query["queryId"], "truthStatus" => hit ? "TRUE_ONLY" : "NEITHER",
+                      "evaluationStatus" => key_conflict_blocks(query["literal"]["predicate"]) ? "NON_EXECUTABLE" : "COMPUTED", "issues" => ISSUES})
+end
+
+begin
+  main
+rescue RT::Refused => e
+  puts JSON.generate({"refused" => e.message})
+  exit 3
+end

arxo_codegen/targets/rb/runtime.rb

@@ -0,0 +1,255 @@
+# Рантайм L0 для Ruby. Тот же контракт, что у runtime.py: точная десятичная
+# арифметика §58 на встроенных целых, деньги с валютой, названный режим
+# округления, календарный день, член перечисления.
+module RT
+  # Названный отказ рантайма: то, что срез не считает, а не сбой. Раннер
+  # печатает его как JSON с кодом выхода 3; любое другое исключение — крах.
+  class Refused < StandardError; end
+
+  Dec = Struct.new(:u, :s)
+  Money = Struct.new(:u, :s, :cur)
+  # Календарный день §2.15 в канонической записи ISO YYYY-MM-DD: порядок
+  # записи и есть порядок дня. Не String: у ключа атома и у сравнения свой вид.
+  Date = Struct.new(:v)
+  # Член перечисления §38 либо иная ссылка const_ref без объявления: значение —
+  # stable qualified identity, равенство по ней (§57), порядок не определён.
+  Sym = Struct.new(:id)
+
+  module_function
+
+  def dec(lit)
+    lit = lit.to_s
+    i, f = lit.split(".", 2)
+    f ||= ""
+    neg = i.start_with?("-")
+    digits = (neg ? i[1..] : i) + f
+    Dec.new(Integer((neg ? "-" : "") + digits, 10), f.length)
+  end
+
+  def money(lit, cur)
+    d = dec(lit)
+    Money.new(d.u, d.s, cur)
+  end
+
+  def date(lit) = Date.new(lit.to_s)
+  def sym(id) = Sym.new(id.to_s)
+
+  def num?(v) = v.is_a?(Dec) || v.is_a?(Money)
+  def money?(v) = v.is_a?(Money)
+
+  # §48/§58: сложение, вычитание, min/max требуют совпадения видов; у денег — и валюты.
+  def same!(a, b, op)
+    raise Refused, "§58: виды операндов не совпадают: #{op}" unless num?(a) && num?(b) && money?(a) == money?(b)
+    raise Refused, "§58: разные валюты: #{op}" if money?(a) && a.cur != b.cur
+  end
+
+  def pair(a, b)
+    s = [a.s, b.s].max
+    [a.u * 10**(s - a.s), b.u * 10**(s - b.s), s]
+  end
+
+  def make(u, s, like) = money?(like) ? Money.new(u, s, like.cur) : Dec.new(u, s)
+
+  # Целое значение: дробная часть нулевая (защита в глубину под статикой плана).
+  def integral?(v) = v.is_a?(Dec) && (v.u % 10**v.s).zero?
+  def to_int(v) = v.u / 10**v.s
+
+  def add(a, b)
+    same!(a, b, "add")
+    x, y, s = pair(a, b)
+    make(x + y, s, a)
+  end
+
+  def sub(a, b)
+    same!(a, b, "sub")
+    x, y, s = pair(a, b)
+    make(x - y, s, a)
+  end
+
+  # Правило скаляра §49: безразмерное масштабирует размерное; масштаб результата —
+  # сумма масштабов. Два размерных не перемножаются.
+  def mul(a, b)
+    raise Refused, "§58: виды операндов не совпадают: mul" unless num?(a) && num?(b)
+    raise Refused, "§58: произведение двух размерных величин не определено" if money?(a) && money?(b)
+    make(a.u * b.u, a.s + b.s, money?(a) ? a : b)
+  end
+
+  # Точное десятичное частное num/den при 10-гладком знаменателе (§18), иначе nil.
+  def exact(num, den)
+    g = num.gcd(den)
+    g = 1 if g.zero?
+    num /= g
+    den /= g
+    if den.negative?
+      num = -num
+      den = -den
+    end
+    twos = fives = 0
+    while (den % 2).zero?
+      den /= 2
+      twos += 1
+    end
+    while (den % 5).zero?
+      den /= 5
+      fives += 1
+    end
+    return nil unless den == 1
+    k = [twos, fives].max
+    [num * 2**(k - twos) * 5**(k - fives), k]
+  end
+
+  # Таблица делимых §58 в срезе: Decimal/Decimal, Money/Decimal, Money/Money одной
+  # валюты. Integer/Integer даёт Rational — вне среза, отвергается планом статически.
+  def div(a, b)
+    raise Refused, "§58: деление вне таблицы делимых" unless num?(a) && num?(b)
+    raise Refused, "деление на ноль — evaluation error (§58)" if b.u.zero?
+    like = nil
+    if money?(a) && money?(b)
+      raise Refused, "CURRENCY_MISMATCH: §58 делит Money на Money только при тождественной валюте" if a.cur != b.cur
+    elsif money?(a)
+      like = a
+    elsif money?(b)
+      raise Refused, "§58: деление вне таблицы делимых"
+    end
+    q = exact(a.u * 10**b.s, b.u * 10**a.s)
+    if q.nil?
+      raise Refused, "INEXACT_DIVISION: округление только явной политикой (§50/§18)" unless like.nil?
+      raise Refused, "§58: частное не 10-гладкое — Rational вне среза"
+    end
+    like.nil? ? Dec.new(q[0], q[1]) : Money.new(q[0], q[1], like.cur)
+  end
+
+  # Евклидов остаток §58: 0 <= r < |b| при любых знаках операндов.
+  def mod(a, b)
+    raise Refused, "§58: mod определён только для Integer" unless integral?(a) && integral?(b)
+    y = to_int(b)
+    raise Refused, "остаток от деления на ноль — evaluation error (§58)" if y.zero?
+    Dec.new(to_int(a) % y.abs, 0)
+  end
+
+  def min(a, b)
+    same!(a, b, "min")
+    x, y, = pair(a, b)
+    x <= y ? a : b
+  end
+
+  def max(a, b)
+    same!(a, b, "max")
+    x, y, = pair(a, b)
+    x >= y ? a : b
+  end
+
+  def abs(v)
+    raise Refused, "§58: abs — не числовой вид" unless num?(v)
+    make(v.u.abs, v.s, v)
+  end
+
+  POW_EXP_LIMIT = 4096
+  POW_MIN = -(2**63)
+  POW_MAX = 2**63 - 1
+
+  # §58 (E-0075): только Integer pow Integer; порядок проверок — знак, предел,
+  # вычисление, диапазон — часть контракта.
+  def pow(base, exp)
+    raise Refused, "§58: pow определён только для Integer" unless integral?(base) && integral?(exp)
+    e = to_int(exp)
+    raise Refused, "§58: pow — показатель отрицателен" if e.negative?
+    raise Refused, "RESOURCE_LIMIT: pow — показатель превышает 4096" if e > POW_EXP_LIMIT
+    r = to_int(base)**e
+    raise Refused, "RESOURCE_LIMIT: pow — результат вне 64-битного диапазона" if r < POW_MIN || r > POW_MAX
+    Dec.new(r, 0)
+  end
+
+  def round(m, digits, mode)
+    raise Refused, "§50: режим округления не реализован: #{mode}" unless mode == "HALF_UP"
+    raise Refused, "§50: round — не числовой вид" unless num?(m)
+    n = digits.is_a?(Integer) ? digits : digits.u / 10**digits.s
+    return make(m.u * 10**(n - m.s), n, m) if m.s <= n
+    drop = 10**(m.s - n)
+    neg = m.u.negative?
+    a = m.u.abs
+    q, r = a.divmod(drop)
+    up = r * 2 >= drop ? q + 1 : q # HALF_UP — от нуля
+    make(neg ? -up : up, n, m)
+  end
+
+  ORDER = {"lt" => ->(x, y) { x < y }, "le" => ->(x, y) { x <= y }, "gt" => ->(x, y) { x > y },
+           "ge" => ->(x, y) { x >= y }, "eq" => ->(x, y) { x == y }, "ne" => ->(x, y) { x != y }}.freeze
+
+  def cmp(a, op, b)
+    if a.is_a?(Sym) || b.is_a?(Sym)
+      same_sym = a.is_a?(Sym) && b.is_a?(Sym) && a.id == b.id
+      return same_sym if op == "eq"
+      return !same_sym if op == "ne"
+      raise Refused, "§57: вид enum не упорядочен"
+    end
+    if a.is_a?(Date) || b.is_a?(Date)
+      if a.is_a?(Date) && b.is_a?(Date)
+        f = ORDER[op]
+        raise Refused, "сравнение вне среза рантайма: #{op}" if f.nil?
+        return f.call(a.v, b.v)
+      end
+      return false if op == "eq"
+      return true if op == "ne"
+      raise Refused, "§57: Date сравнивается только с Date"
+    end
+    if a.is_a?(String) || b.is_a?(String)
+      return a == b if op == "eq"
+      return a != b if op == "ne"
+      raise Refused, "порядок на Text вне среза рантайма: #{op}"
+    end
+    raise Refused, "§49: сравнение денег с безразмерным" if money?(a) != money?(b)
+    raise Refused, "§49: разные валюты" if money?(a) && a.cur != b.cur
+    x, y, = pair(a, b)
+    f = ORDER[op]
+    raise Refused, "сравнение вне среза рантайма: #{op}" if f.nil?
+    f.call(x, y)
+  end
+
+  def eq(a, b)
+    return a.is_a?(Sym) && b.is_a?(Sym) && a.id == b.id if a.is_a?(Sym) || b.is_a?(Sym)
+    return a.is_a?(Date) && b.is_a?(Date) && a.v == b.v if a.is_a?(Date) || b.is_a?(Date)
+    return a == b if a.is_a?(String) || b.is_a?(String)
+    return false if money?(a) != money?(b)
+    return false if money?(a) && a.cur != b.cur
+    x, y, = pair(a, b)
+    x == y
+  end
+
+  def norm(d)
+    u = d.u
+    s = d.s
+    while s.positive? && (u % 10).zero?
+      u /= 10
+      s -= 1
+    end
+    "#{u}e-#{s}"
+  end
+
+  # Разделитель и экран внутри текста экранируются: иначе ["a|e:b","c"] и
+  # ["a","b|e:c"] склеивались в один ключ, и второй факт терялся.
+  def esc(text) = text.gsub("\\", "\\\\\\\\").gsub("|", "\\\\|")
+
+  def key(row)
+    row.map do |v|
+      case v
+      when String then "e:" + esc(v)
+      when Date then "t:" + v.v
+      when Sym then "c:" + esc(v.id)
+      when Money then "m:" + v.cur + ":" + norm(v)
+      else "d:" + norm(v)
+      end
+    end.join("|")
+  end
+
+  @legal_time = ""
+
+  def set_legal_time(t)
+    @legal_time = t.to_s
+  end
+
+  def legal_time
+    raise Refused, "legalTime не подан делом" if @legal_time.empty?
+    @legal_time
+  end
+end