arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/erl/emit.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""Эмиттер Erlang. Модель — модуль `model` с чистым состоянием таблиц: правила
+принимают Db и возвращают {Grew, Db}; порядок строк — порядок добавления."""
+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": "'div'", "mod": "'mod'"}
+FNS = {"round": "round", "min": "min", "max": "max", "abs": "'abs'", "pow": "pow"}
+
+
+def check_plan(plan: dict) -> None:
+    v = plan.get("planVersion")
+    if v != SUPPORTED_PLAN:
+        raise ValueError(f"версия плана не поддержана эмиттером: {v!r} (поддержана {SUPPORTED_PLAN})")
+
+
+def ebin(s: str) -> str:
+    """Бинарная строка Erlang с UTF-8: json.dumps даёт экранирование, совместимое
+    с синтаксисом <<"...">> при ensure_ascii=False, кроме escape-последовательностей
+    JSON, которых в идентификаторах и литералах плана не встречается."""
+    return "<<" + json.dumps(s, ensure_ascii=False) + "/utf8>>"
+
+
+def term(t: dict) -> str:
+    k = t["k"]
+    if k == "var":
+        return f'element({t["col"] + 1}, R{t["row"]})'
+    if k == "lit":
+        if t["t"] == "money":
+            return f'rt:money({ebin(t["v"])}, {ebin(t["cur"])})'
+        if t["t"] == "dec":
+            return f'rt:dec({ebin(t["v"])})'
+        if t["t"] == "date":
+            return f'rt:date({ebin(t["v"])})'
+        if t["t"] == "enum":
+            return f'rt:sym({ebin(t["v"])})'
+        return f'{{text, {ebin(t["v"])}}}'
+    if k == "bin":
+        return f'rt:{OPS[t["op"]]}({term(t["l"])}, {term(t["r"])})'
+    if k == "call":
+        args = t["args"]
+        if t["fn"] == "round":
+            return f'rt:round({term(args[0])}, {term(args[1])}, {ebin(args[2]["v"])})'
+        return f'rt:{FNS[t["fn"]]}(' + ", ".join(term(a) for a in args) + ')'
+    raise AssertionError(k)
+
+
+def emit(plan: dict) -> str:
+    check_plan(plan)
+    L = ["-module(model).",
+         "-export([new/0, rows/2, params/1, consts/1, base/1, keys/1, key_conflicts/1, key_conflict_predicates/1, key_readers/1, register/3, saturate/1, package_facts/1]).", ""]
+    L.append("new() -> #{tables => #{" + ", ".join(f"{ebin(t['pred'])} => []" for t in plan["tables"]) + "}, seen => #{}}.")
+    L.append("")
+    L.append("rows(#{tables := T}, Pred) -> maps:get(Pred, T, []).")
+    L.append("")
+    L.append("%% Объявленные типы параметров: раннер сверяет с ними аргументы дела (§189).")
+    for t in plan["tables"]:
+        L.append(f"params({ebin(t['pred'])}) -> [" + ", ".join(ebin(p) for p in t["params"]) + "];")
+    L.append("params(_) -> undefined.")
+    L.append("")
+    L.append("%% Константы §54: тип для проверки §189 и значение для разыменования аргументов дела.")
+    for cid, c in plan["consts"].items():
+        L.append(f"consts({ebin(cid)}) -> {{{ebin(c['type'])}, {term(c['term'])}}};")
+    L.append("consts(_) -> undefined.")
+    L.append("")
+    L.append("%% Наследование сущностей: подтип подходит параметру базового типа.")
+    for sub, base in plan["bases"].items():
+        L.append(f"base({ebin(sub)}) -> {ebin(base)};")
+    L.append("base(_) -> undefined.")
+    L.append("")
+    L.append("%% Ключи отношений §45.1: позиции столбцов каждого ключа (с единицы).")
+    for t in plan["tables"]:
+        if t["keys"]:
+            L.append(f"keys({ebin(t['pred'])}) -> [" + ", ".join("[" + ", ".join(str(i + 1) for i in k) + "]" for k in t["keys"]) + "];")
+    L.append("keys(_) -> [].")
+    L.append("")
+    L.append("%% KEY_CONFLICT §45.1/§196: группы строк одной таблицы с одинаковой проекцией на ключ; строки уникальны по ключу строки, поэтому группа из двух и более строк — различные accepted-кортежи. Считается после насыщения.")
+    L.append("key_conflicts(#{tables := T} = Db) ->")
+    L.append("    lists:sum([key_conflicts(Db, Pred, Key) || Pred <- maps:keys(T), Key <- keys(Pred)]).")
+    L.append("")
+    L.append("key_conflicts(Db, Pred, Key) ->")
+    L.append("    Groups = lists:foldl(fun(Row, G) ->")
+    L.append("        P = rt:key([element(I, Row) || I <- Key]),")
+    L.append("        maps:update_with(P, fun(C) -> C + 1 end, 1, G)")
+    L.append("    end, #{}, rows(Db, Pred)),")
+    L.append("    length([C || C <- maps:values(Groups), C > 1]).")
+    L.append("")
+    L.append("key_conflict_predicates(#{tables := T} = Db) ->")
+    L.append("    [Pred || Pred <- maps:keys(T), lists:any(fun(Key) -> key_conflicts(Db, Pred, Key) > 0 end, keys(Pred))].")
+    L.append("")
+    readers: dict[str, set[str]] = {}
+    for rule in plan["rules"]:
+        head = rule["head"]["pred"]
+        for atom in rule.get("atoms") or []:
+            readers.setdefault(atom["pred"], set()).add(head)
+        for check in rule.get("checks") or []:
+            readers.setdefault(check["pred"], set()).add(head)
+    for pred, heads in sorted(readers.items()):
+        L.append(f"key_readers({ebin(pred)}) -> [" + ", ".join(ebin(head) for head in sorted(heads)) + "];" )
+    L.append("key_readers(_) -> [].")
+    L.append("")
+    L.append("add_row(#{tables := T, seen := Seen} = Db, Pred, Row) ->")
+    L.append("    K = {Pred, rt:key(tuple_to_list(Row))},")
+    L.append("    case maps:is_key(K, Seen) of")
+    L.append("        true -> {false, Db};")
+    L.append("        false -> {true, Db#{tables := T#{Pred := maps:get(Pred, T) ++ [Row]}, seen := Seen#{K => true}}}")
+    L.append("    end.")
+    L.append("")
+    L.append("register(Db, Pred, Row) -> {_, Db2} = add_row(Db, Pred, Row), Db2.")
+    L.append("")
+    for r in plan["rules"]:
+        L.append(f"%% {r['id']}")
+        L.append(f"rule_{r['name']}(Db0) ->")
+        pre = []
+        if r["window"]:
+            if r["window"].get("start"):
+                pre.append(f"rt:legal_time() < {ebin(r['window']['start'])}")
+            if r["window"].get("end"):
+                pre.append(f"rt:legal_time() >= {ebin(r['window']['end'])}")
+        if pre:
+            L.append("    case " + " orelse ".join(pre) + " of true -> {false, Db0}; false ->")
+        n = len(r["atoms"])
+        # вложенные свёртки: снимок строк каждой таблицы берётся из Db на входе в цикл
+        body = []
+        ind = "    "
+        for i, a in enumerate(r["atoms"]):
+            body.append(f"{ind}lists:foldl(fun(R{i}, {{G{i}, Db{i + 1}}}) ->")
+            ind += "    "
+        checks = [f'rt:cmp(element({aj + 1}, R{ai}), <<"eq">>, element({bj + 1}, R{bi}))'
+                  for (ai, aj, _at), (bi, bj, _bt) in r["joins"]]
+        checks += [f'rt:eq(element({f["col"] + 1}, R{f["row"]}), {term(f["term"])})' for f in r["filters"]]
+        checks += [f'rt:cmp({term(g["l"])}, {ebin(g["op"])}, {term(g["r"])})' for g in r["guards"]]
+        gname = f"G{n - 1}" if n else "false"
+        dbname = f"Db{n}"
+        for c in checks:
+            body.append(f"{ind}case {c} of false -> {{{gname}, {dbname}}}; true ->")
+            ind += "    "
+        args = ", ".join(term(a) for a in r["head"]["args"])
+        body.append(f"{ind}case add_row({dbname}, {ebin(r['head']['pred'])}, list_to_tuple([{args}])) of")
+        body.append(f"{ind}    {{true, DbN}} -> {{true, DbN}};")
+        body.append(f"{ind}    {{false, DbN}} -> {{{gname}, DbN}}")
+        body.append(f"{ind}end")
+        for _ in checks:
+            ind = ind[:-4]
+            body.append(f"{ind}end")
+        for i in reversed(range(n)):
+            ind = ind[:-4]
+            gprev = f"G{i - 1}" if i > 0 else "false"
+            dbprev = f"Db{i}"
+            body.append(f"{ind}end, {{{gprev}, {dbprev}}}, rows({dbprev}, {ebin(r['atoms'][i]['pred'])}))")
+        L += body
+        if pre:
+            L.append("    end.")
+        else:
+            L[-1] = L[-1] + "."
+        L.append("")
+    names = [r["name"] for r in plan["rules"]]
+    L.append("saturate(Db0) ->")
+    if names:
+        L.append("    {Grew, Db} = lists:foldl(fun(Rule, {G, D}) -> {G2, D2} = Rule(D), {G orelse G2, D2} end, {false, Db0},")
+        L.append("        [" + ", ".join(f"fun rule_{n}/1" for n in names) + "]),")
+        L.append("    case Grew of true -> saturate(Db); false -> Db end.")
+    else:
+        L.append("    Db0.")
+    L.append("")
+    L.append("package_facts(Db0) ->")
+    if plan["facts"]:
+        L.append("    lists:foldl(fun({P, Row}, Db) -> register(Db, P, Row) end, Db0, [")
+        L.append(",\n".join(f"        {{{ebin(f['pred'])}, list_to_tuple([" + ", ".join(term(a) for a in f["args"]) + "])}" for f in plan["facts"]))
+        L.append("    ]).")
+    else:
+        L.append("    Db0.")
+    return "\n".join(L) + "\n"
+
+
+# --- дескриптор цели ---------------------------------------------------------
+HERE = Path(__file__).resolve().parent
+EXT = "erl"
+MODEL = "model.erl"
+MAINS = {"runner": "runner.erl", "cert": "cert.erl"}
+
+
+def available():
+    erlc, erl = shutil.which("erlc"), shutil.which("erl")
+    return (True, erl) if erlc and erl else (False, "нет erlc/erl в PATH")
+
+
+def layout(proj, main: str) -> list:
+    proj = Path(proj)
+    proj.mkdir(parents=True, exist_ok=True)
+    out = []
+    for name in ("rt.erl", MAINS[main]):
+        shutil.copyfile(HERE / name, proj / name)
+        out.append(proj / name)
+    return out
+
+
+def build(proj):
+    proj = Path(proj)
+    (proj / "out").mkdir(exist_ok=True)
+    return ["erlc", "-o", "out"] + sorted(p.name for p in proj.glob("*.erl")), str(proj)
+
+
+def run(proj, main: str):
+    module = MAINS[main][:-4]
+    return ["erl", "-noshell", "-pa", str(Path(proj) / "out"), "-run", module, "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/erl/rt.erl

@@ -0,0 +1,238 @@
+%% Рантайм L0 для Erlang. Тот же контракт, что у runtime.py: точная десятичная
+%% арифметика §58 на встроенных целых, деньги с валютой, названный режим
+%% округления, календарный день, член перечисления. Отказ — throw({refused, Msg}),
+%% любая другая ошибка — крах.
+-module(rt).
+-compile({no_auto_import, [abs/1, max/2, min/2]}).
+-export([dec/1, money/2, date/1, sym/1, add/2, sub/2, mul/2, 'div'/2, 'mod'/2,
+         min/2, max/2, 'abs'/1, pow/2, round/3, cmp/3, eq/2, key/1,
+         set_legal_time/1, legal_time/0, refuse/1]).
+
+%% Значения: {dec, U, S} | {money, U, S, Cur} | {text, T} | {date, D} | {sym, Id}.
+refuse(Msg) -> throw({refused, unicode:characters_to_binary(Msg)}).
+
+p10(N) -> pow10(N, 1).
+pow10(0, Acc) -> Acc;
+pow10(N, Acc) -> pow10(N - 1, Acc * 10).
+
+dec(Lit) when is_binary(Lit) -> dec(unicode:characters_to_list(Lit));
+dec(Lit) ->
+    {I, F} = case string:split(Lit, ".") of [A, B] -> {A, B}; [A] -> {A, ""} end,
+    Neg = lists:prefix("-", I),
+    Digits = (case Neg of true -> tl(I); false -> I end) ++ F,
+    U = list_to_integer(Digits),
+    {dec, case Neg of true -> -U; false -> U end, length(F)}.
+
+money(Lit, Cur) -> {dec, U, S} = dec(Lit), {money, U, S, unicode:characters_to_binary(Cur)}.
+date(Lit) -> {date, unicode:characters_to_binary(Lit)}.
+sym(Id) -> {sym, unicode:characters_to_binary(Id)}.
+
+%% --- виды -------------------------------------------------------------------
+num({dec, U, S}) -> {U, S, none};
+num({money, U, S, C}) -> {U, S, C};
+num(_) -> false.
+
+is_money({money, _, _, _}) -> true;
+is_money(_) -> false.
+
+%% §48/§58: сложение, вычитание, min/max требуют совпадения видов; у денег — и валюты.
+same(A, B, Op) ->
+    case {num(A), num(B)} of
+        {{_, _, CA}, {_, _, CB}} when (CA =:= none) =:= (CB =:= none) ->
+            case CA =/= none andalso CA =/= CB of
+                true -> refuse(["§58: разные валюты: ", Op]);
+                false -> ok
+            end;
+        _ -> refuse(["§58: виды операндов не совпадают: ", Op])
+    end.
+
+pair(A, B) ->
+    {AU, AS, _} = num(A), {BU, BS, _} = num(B),
+    S = erlang:max(AS, BS),
+    {AU * p10(S - AS), BU * p10(S - BS), S}.
+
+mk(U, S, {money, _, _, C}) -> {money, U, S, C};
+mk(U, S, _) -> {dec, U, S}.
+
+%% Целое значение: дробная часть нулевая (защита в глубину под статикой плана).
+integral({dec, U, S}) ->
+    case U rem p10(S) of 0 -> {ok, U div p10(S)}; _ -> false end;
+integral(_) -> false.
+
+%% --- арифметика §58 ---------------------------------------------------------
+add(A, B) -> same(A, B, "add"), {X, Y, S} = pair(A, B), mk(X + Y, S, A).
+sub(A, B) -> same(A, B, "sub"), {X, Y, S} = pair(A, B), mk(X - Y, S, A).
+
+%% Правило скаляра §49: безразмерное масштабирует размерное; масштаб результата —
+%% сумма масштабов. Два размерных не перемножаются.
+mul(A, B) ->
+    case {num(A), num(B)} of
+        {{AU, AS, CA}, {BU, BS, CB}} ->
+            case CA =/= none andalso CB =/= none of
+                true -> refuse("§58: произведение двух размерных величин не определено");
+                false -> ok
+            end,
+            Like = case CA of none -> B; _ -> A end,
+            mk(AU * BU, AS + BS, Like);
+        _ -> refuse("§58: виды операндов не совпадают: mul")
+    end.
+
+gcd(A, 0) -> erlang:abs(A);
+gcd(A, B) -> gcd(B, A rem B).
+
+strip(D, P, N) -> case D rem P of 0 -> strip(D div P, P, N + 1); _ -> {D, N} end.
+
+%% Точное десятичное частное Num/Den при 10-гладком знаменателе (§18), иначе none.
+exact(Num0, Den0) ->
+    G = case gcd(Num0, Den0) of 0 -> 1; X -> X end,
+    {Num1, Den1} = {Num0 div G, Den0 div G},
+    {Num, Den} = case Den1 < 0 of true -> {-Num1, -Den1}; false -> {Num1, Den1} end,
+    {D2, Twos} = strip(Den, 2, 0),
+    {D5, Fives} = strip(D2, 5, 0),
+    case D5 of
+        1 -> K = erlang:max(Twos, Fives),
+             {Num * pow_int(2, K - Twos) * pow_int(5, K - Fives), K};
+        _ -> none
+    end.
+
+pow_int(_, 0) -> 1;
+pow_int(B, E) -> B * pow_int(B, E - 1).
+
+%% Таблица делимых §58 в срезе: Decimal/Decimal, Money/Decimal, Money/Money одной
+%% валюты. Integer/Integer даёт Rational — вне среза, отвергается планом статически.
+'div'(A, B) ->
+    case {num(A), num(B)} of
+        {{AU, AS, CA}, {BU, BS, CB}} ->
+            case BU of 0 -> refuse("деление на ноль — evaluation error (§58)"); _ -> ok end,
+            Like = case {CA, CB} of
+                {none, none} -> none;
+                {_, none} -> A;
+                {none, _} -> refuse("§58: деление вне таблицы делимых");
+                {C, C} -> none;
+                {_, _} -> refuse("CURRENCY_MISMATCH: §58 делит Money на Money только при тождественной валюте")
+            end,
+            case exact(AU * p10(BS), BU * p10(AS)) of
+                none when Like =/= none -> refuse("INEXACT_DIVISION: округление только явной политикой (§50/§18)");
+                none -> refuse("§58: частное не 10-гладкое — Rational вне среза");
+                {U, S} when Like =:= none -> {dec, U, S};
+                {U, S} -> mk(U, S, Like)
+            end;
+        _ -> refuse("§58: деление вне таблицы делимых")
+    end.
+
+%% Евклидов остаток §58: 0 <= r < |b| при любых знаках операндов.
+'mod'(A, B) ->
+    case {integral(A), integral(B)} of
+        {{ok, _}, {ok, 0}} -> refuse("остаток от деления на ноль — evaluation error (§58)");
+        {{ok, X}, {ok, Y}} -> M = erlang:abs(Y), {dec, ((X rem M) + M) rem M, 0};
+        _ -> refuse("§58: mod определён только для Integer")
+    end.
+
+min(A, B) -> same(A, B, "min"), {X, Y, _} = pair(A, B), case X =< Y of true -> A; false -> B end.
+max(A, B) -> same(A, B, "max"), {X, Y, _} = pair(A, B), case X >= Y of true -> A; false -> B end.
+
+'abs'(V) ->
+    case num(V) of
+        {U, S, _} -> mk(erlang:abs(U), S, V);
+        false -> refuse("§58: abs — не числовой вид")
+    end.
+
+%% §58 (E-0075): только Integer pow Integer; порядок проверок — знак, предел,
+%% вычисление, диапазон — часть контракта.
+pow(Base, Exp) ->
+    case {integral(Base), integral(Exp)} of
+        {{ok, X}, {ok, E}} ->
+            case E < 0 of true -> refuse("§58: pow — показатель отрицателен"); false -> ok end,
+            case E > 4096 of true -> refuse("RESOURCE_LIMIT: pow — показатель превышает 4096"); false -> ok end,
+            R = pow_int(X, E),
+            case R < -(1 bsl 63) orelse R > (1 bsl 63) - 1 of
+                true -> refuse("RESOURCE_LIMIT: pow — результат вне 64-битного диапазона");
+                false -> {dec, R, 0}
+            end;
+        _ -> refuse("§58: pow определён только для Integer")
+    end.
+
+round(M, Digits, Mode) ->
+    case Mode of <<"HALF_UP">> -> ok; "HALF_UP" -> ok; _ -> refuse(["§50: режим округления не реализован: ", Mode]) end,
+    case num(M) of
+        false -> refuse("§50: round — не числовой вид");
+        {MU, MS, _} ->
+            N = case num(Digits) of {DU, DS, _} -> DU div p10(DS); false -> 0 end,
+            case MS =< N of
+                true -> mk(MU * p10(N - MS), N, M);
+                false ->
+                    Drop = p10(MS - N),
+                    A = erlang:abs(MU), Q = A div Drop, R = A rem Drop,
+                    Up = case R * 2 >= Drop of true -> Q + 1; false -> Q end,
+                    mk(case MU < 0 of true -> -Up; false -> Up end, N, M)
+            end
+    end.
+
+%% --- сравнение и равенство ---------------------------------------------------
+ordered(<<"lt">>, X, Y) -> X < Y;
+ordered(<<"le">>, X, Y) -> X =< Y;
+ordered(<<"gt">>, X, Y) -> X > Y;
+ordered(<<"ge">>, X, Y) -> X >= Y;
+ordered(<<"eq">>, X, Y) -> X =:= Y;
+ordered(<<"ne">>, X, Y) -> X =/= Y;
+ordered(Op, _, _) -> refuse(["сравнение вне среза рантайма: ", Op]).
+
+op_bin(Op) when is_list(Op) -> unicode:characters_to_binary(Op);
+op_bin(Op) -> Op.
+
+cmp(A, Op0, B) ->
+    Op = op_bin(Op0),
+    case {A, B} of
+        {{sym, X}, {sym, Y}} -> case Op of <<"eq">> -> X =:= Y; <<"ne">> -> X =/= Y; _ -> refuse("§57: вид enum не упорядочен") end;
+        {{sym, _}, _} -> case Op of <<"eq">> -> false; <<"ne">> -> true; _ -> refuse("§57: вид enum не упорядочен") end;
+        {_, {sym, _}} -> case Op of <<"eq">> -> false; <<"ne">> -> true; _ -> refuse("§57: вид enum не упорядочен") end;
+        {{date, X}, {date, Y}} -> ordered(Op, X, Y);
+        {{date, _}, _} -> case Op of <<"eq">> -> false; <<"ne">> -> true; _ -> refuse("§57: Date сравнивается только с Date") end;
+        {_, {date, _}} -> case Op of <<"eq">> -> false; <<"ne">> -> true; _ -> refuse("§57: Date сравнивается только с Date") end;
+        {{text, X}, {text, Y}} -> case Op of <<"eq">> -> X =:= Y; <<"ne">> -> X =/= Y; _ -> refuse(["порядок на Text вне среза рантайма: ", Op]) end;
+        {{text, _}, _} -> case Op of <<"eq">> -> false; <<"ne">> -> true; _ -> refuse(["порядок на Text вне среза рантайма: ", Op]) end;
+        {_, {text, _}} -> case Op of <<"eq">> -> false; <<"ne">> -> true; _ -> refuse(["порядок на Text вне среза рантайма: ", Op]) end;
+        _ ->
+            case is_money(A) =/= is_money(B) of true -> refuse("§49: сравнение денег с безразмерным"); false -> ok end,
+            case is_money(A) andalso element(4, A) =/= element(4, B) of true -> refuse("§49: разные валюты"); false -> ok end,
+            {X, Y, _} = pair(A, B),
+            ordered(Op, X, Y)
+    end.
+
+eq({sym, X}, {sym, Y}) -> X =:= Y;
+eq({sym, _}, _) -> false;
+eq(_, {sym, _}) -> false;
+eq({date, X}, {date, Y}) -> X =:= Y;
+eq({date, _}, _) -> false;
+eq(_, {date, _}) -> false;
+eq({text, X}, {text, Y}) -> X =:= Y;
+eq({text, _}, _) -> false;
+eq(_, {text, _}) -> false;
+eq(A, B) ->
+    case is_money(A) =/= is_money(B) orelse (is_money(A) andalso element(4, A) =/= element(4, B)) of
+        true -> false;
+        false -> {X, Y, _} = pair(A, B), X =:= Y
+    end.
+
+norm(U, S) when S > 0, U rem 10 =:= 0 -> norm(U div 10, S - 1);
+norm(U, S) -> [integer_to_binary(U), <<"e-">>, integer_to_binary(S)].
+
+%% Разделитель и экран внутри текста экранируются: иначе ["a|e:b","c"] и
+%% ["a","b|e:c"] склеивались в один ключ, и второй факт терялся.
+esc(T) -> binary:replace(binary:replace(T, <<"\\">>, <<"\\\\">>, [global]), <<"|">>, <<"\\|">>, [global]).
+
+cell({text, T}) -> [<<"e:">>, esc(T)];
+cell({date, D}) -> [<<"t:">>, D];
+cell({sym, I}) -> [<<"c:">>, esc(I)];
+cell({money, U, S, C}) -> [<<"m:">>, C, <<":">>, norm(U, S)];
+cell({dec, U, S}) -> [<<"d:">>, norm(U, S)].
+
+key(Row) -> iolist_to_binary(lists:join(<<"|">>, [cell(V) || V <- Row])).
+
+set_legal_time(T) -> put(law_legal_time, unicode:characters_to_binary(T)).
+legal_time() ->
+    case get(law_legal_time) of
+        undefined -> refuse("legalTime не подан делом");
+        <<>> -> refuse("legalTime не подан делом");
+        T -> T
+    end.

arxo_codegen/targets/erl/runner.erl

@@ -0,0 +1,130 @@
+%% Раннер Erlang-бэкенда: тот же вход и тот же ответ, что у runner.py.
+%%
+%% Протокол выхода общий для всех целей: ответ — JSON и код 0; названный отказ
+%% среза — JSON {"refused": текст} и код 3; любой другой код — крах.
+-module(runner).
+-export([main/1]).
+
+text(V) when is_binary(V) -> V;
+text(V) when is_integer(V) -> integer_to_binary(V);
+text(V) when is_atom(V) -> atom_to_binary(V, utf8);
+text(V) -> iolist_to_binary(json:encode(V)).
+
+get(M, K) -> maps:get(K, M, undefined).
+get(M, K, D) -> maps:get(K, M, D).
+
+arg(A) ->
+    case get(A, <<"kind">>) of
+        <<"entity_ref">> -> {text, get(A, <<"id">>)};
+        <<"const_ref">> ->
+            %% §54: разыменование предшествует исполнению; член перечисления §38 либо
+            %% имя без объявления остаётся идентичностью, как в ключе атома оракула.
+            case model:consts(get(A, <<"id">>)) of
+                undefined -> rt:sym(get(A, <<"id">>));
+                {_, V} -> V
+            end;
+        <<"value">> ->
+            T = get(get(A, <<"type">>, #{}), <<"name">>),
+            V = text(get(A, <<"value">>)),
+            case T of
+                <<"urn:law:std#Money">> -> rt:money(V, get(A, <<"currency">>));
+                <<"urn:law:std#Decimal">> -> rt:dec(V);
+                <<"urn:law:std#Integer">> -> rt:dec(V);
+                <<"urn:law:std#Text">> -> {text, V};
+                <<"urn:law:std#Date">> -> rt:date(V);
+                _ -> rt:refuse(["аргумент вне среза раннера: ", text(T)])
+            end;
+        K -> rt:refuse(["аргумент вне среза раннера: ", text(K)])
+    end.
+
+%% Тип аргумента, если известен: у value — из узла, у const_ref — из объявления
+%% константы; entity_ref типа не несёт (как у оракула).
+arg_type(A) ->
+    case get(A, <<"kind">>) of
+        <<"value">> -> get(get(A, <<"type">>, #{}), <<"name">>);
+        <<"const_ref">> -> case model:consts(get(A, <<"id">>)) of undefined -> undefined; {T, _} -> T end;
+        _ -> undefined
+    end.
+
+%% Совпадение типа с наследованием сущностей вверх от фактического.
+conforms(Actual, Expected) -> conforms(Actual, Expected, #{}).
+conforms(undefined, _, _) -> false;
+conforms(Expected, Expected, _) -> true;
+conforms(Cur, Expected, Seen) ->
+    case maps:is_key(Cur, Seen) of
+        true -> false;
+        false -> conforms(model:base(Cur), Expected, Seen#{Cur => true})
+    end.
+
+typed(Params, Args) ->
+    length(Params) =:= length(Args) andalso
+        lists:all(fun({E, A}) -> case arg_type(A) of undefined -> true; T -> conforms(T, E) end end,
+                  lists:zip(Params, Args)).
+
+%% E-0210/E-0242: a conflict blocks its relation and transitive rule readers,
+%% not independent queries in the same program.
+key_conflict_blocks(Db, Predicate) ->
+    closure(model:key_conflict_predicates(Db), Predicate, #{}).
+closure([], Predicate, Seen) -> maps:is_key(Predicate, Seen);
+closure([Source | Rest], Predicate, Seen) ->
+    case maps:is_key(Source, Seen) of
+        true -> closure(Rest, Predicate, Seen);
+        false -> closure(Rest ++ model:key_readers(Source), Predicate, Seen#{Source => true})
+    end.
+
+main([CasePath, QueryPath]) ->
+    try
+        {ok, CaseBin} = file:read_file(CasePath),
+        {ok, QueryBin} = file:read_file(QueryPath),
+        Case = json:decode(CaseBin),
+        Query = json:decode(QueryBin),
+        rt:set_legal_time(text(get(get(Case, <<"context">>, #{}), <<"legalTime">>, <<>>))),
+        Db0 = model:package_facts(model:new()),
+        {Db1, Issues} = lists:foldl(fun(A, {Db, Iss}) ->
+            Lit = get(A, <<"literal">>),
+            case get(Lit, <<"polarity">>) of <<"positive">> -> ok; _ -> rt:refuse("§113: отрицательный факт вне L0-среза") end,
+            Pred = get(Lit, <<"predicate">>),
+            Args = get(Lit, <<"args">>, []),
+            case model:params(Pred) of
+                undefined -> {Db, Iss};
+                Params ->
+                    %% Арность и типы аргументов утверждения против сигнатуры §189 (E-0046).
+                    case typed(Params, Args) of
+                        false -> {Db, Iss ++ [<<"TYPE_ERROR">>]};
+                        true -> {model:register(Db, Pred, list_to_tuple([arg(X) || X <- Args])), Iss}
+                    end
+            end
+        end, {Db0, []}, get(Case, <<"assertions">>, [])),
+        Db2 = model:saturate(Db1),
+        Issues2 = Issues ++ lists:duplicate(model:key_conflicts(Db2), <<"KEY_CONFLICT">>),
+        case get(Query, <<"kind">>) of <<"truth">> -> ok; K -> rt:refuse(["вид запроса вне среза раннера: ", text(K)]) end,
+        QLit = get(Query, <<"literal">>),
+        QPred = get(QLit, <<"predicate">>),
+        QArgs = get(QLit, <<"args">>, []),
+        %% Ключ атома у оракула §208 включает ТИП значения: несогласованный запрос
+        %% атома не находит — NEITHER без issue.
+        Hit = case model:params(QPred) of
+            undefined -> false;
+            QParams ->
+                case typed(QParams, QArgs) of
+                    false -> false;
+                    true ->
+                        Want = [arg(X) || X <- QArgs],
+                        lists:any(fun(Row) ->
+                            R = tuple_to_list(Row),
+                            length(R) =:= length(Want) andalso lists:all(fun({V, W}) -> rt:eq(V, W) end, lists:zip(R, Want))
+                        end, model:rows(Db2, QPred))
+                end
+        end,
+        %% Открытый мир: отсутствие строки — это NEITHER, а не FALSE_ONLY.
+        Out = #{<<"queryId">> => get(Query, <<"queryId">>),
+                <<"truthStatus">> => case Hit of true -> <<"TRUE_ONLY">>; false -> <<"NEITHER">> end,
+                <<"evaluationStatus">> => case key_conflict_blocks(Db2, QPred) of true -> <<"NON_EXECUTABLE">>; false -> <<"COMPUTED">> end,
+                <<"issues">> => Issues2},
+        io:format("~ts~n", [json:encode(Out)]),
+        erlang:halt(0)
+    catch
+        throw:{refused, Msg} ->
+            io:format("~ts~n", [json:encode(#{<<"refused">> => Msg})]),
+            erlang:halt(3)
+    end.

arxo_codegen/targets/ex/cert.exs

@@ -0,0 +1,62 @@
+# Харнесс сертификации рантайма: исполняет runtime-cert.json и печатает,
+# что получилось. Ожидания сверяют ворота, харнесс их не читает.
+Code.require_file("runtime.ex", __DIR__)
+
+defmodule LawCert do
+  def lit(x) when is_binary(x), do: x
+  def lit(%{"dec" => d}), do: LawRT.dec(d)
+  def lit(%{"money" => m, "cur" => c}), do: LawRT.money(m, c)
+  def lit(%{"text" => t}), do: {:text, t}
+  def lit(%{"date" => d}), do: LawRT.date(d)
+  def lit(%{"sym" => s}), do: LawRT.sym(s)
+  def lit(%{"row" => r}), do: Enum.map(r, &lit/1)
+
+  # Отображение с ЯВНЫМ масштабом: 2.00 и 2 — разные записи одного значения.
+  def digits(u, s) do
+    body = Integer.to_string(abs(u)) |> String.pad_leading(s + 1, "0")
+    text = if s == 0, do: body, else: String.slice(body, 0, String.length(body) - s) <> "." <> String.slice(body, -s, s)
+    if u < 0, do: "-" <> text, else: text
+  end
+
+  def render(nil), do: nil
+  def render(b) when is_boolean(b), do: b
+  def render({:text, t}), do: t
+  def render({:money, u, s, c}), do: digits(u, s) <> " " <> c
+  def render({:date, d}), do: d
+  def render({:sym, i}), do: i
+  def render({:dec, u, s}), do: digits(u, s)
+
+  def run(%{"op" => op, "args" => raw}) do
+    a = Enum.map(raw, &lit/1)
+    case op do
+      "dec" -> LawRT.dec(Enum.at(a, 0))
+      "money" -> LawRT.money(Enum.at(a, 0), Enum.at(a, 1))
+      "date" -> LawRT.date(Enum.at(a, 0))
+      "sym" -> LawRT.sym(Enum.at(a, 0))
+      "add" -> LawRT.add(Enum.at(a, 0), Enum.at(a, 1))
+      "sub" -> LawRT.sub(Enum.at(a, 0), Enum.at(a, 1))
+      "mul" -> LawRT.mul(Enum.at(a, 0), Enum.at(a, 1))
+      "div" -> LawRT.divide(Enum.at(a, 0), Enum.at(a, 1))
+      "mod" -> LawRT.modulo(Enum.at(a, 0), Enum.at(a, 1))
+      "min" -> LawRT.min(Enum.at(a, 0), Enum.at(a, 1))
+      "max" -> LawRT.max(Enum.at(a, 0), Enum.at(a, 1))
+      "abs" -> LawRT.absolute(Enum.at(a, 0))
+      "pow" -> LawRT.pow(Enum.at(a, 0), Enum.at(a, 1))
+      "round" -> LawRT.round(Enum.at(a, 0), Enum.at(a, 1), Enum.at(a, 2))
+      "cmp" -> LawRT.cmp(Enum.at(a, 0), Enum.at(a, 1), Enum.at(a, 2))
+      "eq" -> LawRT.eq(Enum.at(a, 0), Enum.at(a, 1))
+      "keyEq" -> LawRT.key(Enum.at(a, 0)) == LawRT.key(Enum.at(a, 1))
+      "legalTime" -> {:text, LawRT.legal_time()}
+      "setLegalTime" -> (LawRT.set_legal_time(Enum.at(a, 0)); nil)
+    end
+  end
+end
+
+[path] = System.argv()
+fixture = JSON.decode!(File.read!(path))
+out =
+  Enum.map(fixture["cases"], fn c ->
+    got = try do LawCert.render(LawCert.run(c)) catch {:refused, msg} -> %{"refused" => msg} end
+    %{"id" => c["id"], "got" => got}
+  end)
+IO.puts(JSON.encode!(out))