arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/rs/runtime.rs

@@ -0,0 +1,448 @@
+#![allow(dead_code)]
+//! Рантайм L0 для Rust. Тот же контракт, что у runtime.py: точная десятичная
+//! арифметика §58 на `num-bigint`, деньги с валютой, названный режим
+//! округления, календарный день, член перечисления. Отказ — `Err(Refused)`,
+//! не panic: panic остаётся крахом.
+use num_bigint::BigInt;
+use num_integer::Integer;
+use num_traits::{One, Signed, ToPrimitive, Zero};
+use std::collections::BTreeSet;
+
+#[derive(Clone, Debug)]
+pub enum Val {
+    Text(String),
+    Dec { u: BigInt, s: usize },
+    Money { u: BigInt, s: usize, cur: String },
+    /// Календарный день §2.15 в канонической записи ISO YYYY-MM-DD.
+    Date(String),
+    /// Член перечисления §38 либо ссылка const_ref без объявления.
+    Sym(String),
+}
+
+/// Названный отказ рантайма: то, что срез не считает, а не сбой.
+#[derive(Debug)]
+pub struct Refused(pub String);
+
+pub type R<T> = Result<T, Refused>;
+
+fn refuse<T>(msg: impl Into<String>) -> R<T> {
+    Err(Refused(msg.into()))
+}
+
+fn p10(n: usize) -> BigInt {
+    num_traits::pow(BigInt::from(10), n)
+}
+
+pub fn dec(lit: &str) -> Val {
+    let (i, f) = match lit.split_once('.') {
+        Some((i, f)) => (i, f),
+        None => (lit, ""),
+    };
+    let neg = i.starts_with('-');
+    let digits = format!("{}{}", if neg { &i[1..] } else { i }, f);
+    let mut u: BigInt = digits.parse().expect("десятичный литерал");
+    if neg {
+        u = -u;
+    }
+    Val::Dec { u, s: f.len() }
+}
+
+pub fn money(lit: &str, cur: &str) -> Val {
+    match dec(lit) {
+        Val::Dec { u, s } => Val::Money { u, s, cur: cur.to_string() },
+        _ => unreachable!(),
+    }
+}
+
+pub fn date(lit: &str) -> Val {
+    Val::Date(lit.to_string())
+}
+
+pub fn sym(id: &str) -> Val {
+    Val::Sym(id.to_string())
+}
+
+pub fn text(t: &str) -> Val {
+    Val::Text(t.to_string())
+}
+
+// --- виды -------------------------------------------------------------------
+
+/// Числовое значение: мантисса, масштаб, валюта.
+fn num(v: &Val) -> Option<(&BigInt, usize, Option<&str>)> {
+    match v {
+        Val::Dec { u, s } => Some((u, *s, None)),
+        Val::Money { u, s, cur } => Some((u, *s, Some(cur))),
+        _ => None,
+    }
+}
+
+/// §48/§58: сложение, вычитание, min/max требуют совпадения видов; у денег — и валюты.
+fn same(a: &Val, b: &Val, op: &str) -> R<()> {
+    match (num(a), num(b)) {
+        (Some((_, _, ca)), Some((_, _, cb))) if ca.is_some() == cb.is_some() => {
+            if ca.is_some() && ca != cb {
+                return refuse(format!("§58: разные валюты: {op}"));
+            }
+            Ok(())
+        }
+        _ => refuse(format!("§58: виды операндов не совпадают: {op}")),
+    }
+}
+
+fn pair(a: &Val, b: &Val) -> (BigInt, BigInt, usize) {
+    let (au, sa, _) = num(a).expect("число");
+    let (bu, sb, _) = num(b).expect("число");
+    let s = sa.max(sb);
+    (au * p10(s - sa), bu * p10(s - sb), s)
+}
+
+fn mk(u: BigInt, s: usize, like: &Val) -> Val {
+    match like {
+        Val::Money { cur, .. } => Val::Money { u, s, cur: cur.clone() },
+        _ => Val::Dec { u, s },
+    }
+}
+
+/// Целое значение: дробная часть нулевая (защита в глубину под статикой плана).
+fn integral(v: &Val) -> Option<BigInt> {
+    match v {
+        Val::Dec { u, s } => {
+            let (q, r) = u.div_rem(&p10(*s));
+            if r.is_zero() {
+                Some(q)
+            } else {
+                None
+            }
+        }
+        _ => None,
+    }
+}
+
+// --- арифметика §58 ---------------------------------------------------------
+
+pub fn add(a: &Val, b: &Val) -> R<Val> {
+    same(a, b, "add")?;
+    let (x, y, s) = pair(a, b);
+    Ok(mk(x + y, s, a))
+}
+
+pub fn sub(a: &Val, b: &Val) -> R<Val> {
+    same(a, b, "sub")?;
+    let (x, y, s) = pair(a, b);
+    Ok(mk(x - y, s, a))
+}
+
+/// Правило скаляра §49: безразмерное масштабирует размерное; масштаб результата —
+/// сумма масштабов. Два размерных не перемножаются.
+pub fn mul(a: &Val, b: &Val) -> R<Val> {
+    let (Some((au, sa, ca)), Some((bu, sb, cb))) = (num(a), num(b)) else {
+        return refuse("§58: виды операндов не совпадают: mul");
+    };
+    if ca.is_some() && cb.is_some() {
+        return refuse("§58: произведение двух размерных величин не определено");
+    }
+    let like = if ca.is_some() { a } else { b };
+    Ok(mk(au * bu, sa + sb, like))
+}
+
+/// Точное десятичное частное num/den при 10-гладком знаменателе (§18).
+fn exact(num: BigInt, den: BigInt) -> Option<(BigInt, usize)> {
+    let g = num.abs().gcd(&den.abs());
+    let g = if g.is_zero() { BigInt::one() } else { g };
+    let mut num = &num / &g;
+    let mut den = &den / &g;
+    if den.is_negative() {
+        num = -num;
+        den = -den;
+    }
+    let (two, five) = (BigInt::from(2), BigInt::from(5));
+    let (mut twos, mut fives) = (0usize, 0usize);
+    while (&den % &two).is_zero() {
+        den /= &two;
+        twos += 1;
+    }
+    while (&den % &five).is_zero() {
+        den /= &five;
+        fives += 1;
+    }
+    if !den.is_one() {
+        return None;
+    }
+    let k = twos.max(fives);
+    Some((num * num_traits::pow(two, k - twos) * num_traits::pow(five, k - fives), k))
+}
+
+/// Таблица делимых §58 в срезе: Decimal/Decimal, Money/Decimal, Money/Money одной
+/// валюты. Integer/Integer даёт Rational — вне среза, отвергается планом статически.
+pub fn div(a: &Val, b: &Val) -> R<Val> {
+    let (Some((au, sa, ca)), Some((bu, sb, cb))) = (num(a), num(b)) else {
+        return refuse("§58: деление вне таблицы делимых");
+    };
+    if bu.is_zero() {
+        return refuse("деление на ноль — evaluation error (§58)");
+    }
+    let like: Option<&str> = match (ca, cb) {
+        (Some(x), Some(y)) => {
+            if x != y {
+                return refuse("CURRENCY_MISMATCH: §58 делит Money на Money только при тождественной валюте");
+            }
+            None
+        }
+        (Some(x), None) => Some(x),
+        (None, Some(_)) => return refuse("§58: деление вне таблицы делимых"),
+        (None, None) => None,
+    };
+    match exact(au * p10(sb), bu * p10(sa)) {
+        Some((u, s)) => Ok(match like {
+            Some(cur) => Val::Money { u, s, cur: cur.to_string() },
+            None => Val::Dec { u, s },
+        }),
+        None => {
+            if like.is_some() {
+                refuse("INEXACT_DIVISION: округление только явной политикой (§50/§18)")
+            } else {
+                refuse("§58: частное не 10-гладкое — Rational вне среза")
+            }
+        }
+    }
+}
+
+/// Евклидов остаток §58: 0 <= r < |b| при любых знаках операндов.
+pub fn modulo(a: &Val, b: &Val) -> R<Val> {
+    let (Some(x), Some(y)) = (integral(a), integral(b)) else {
+        return refuse("§58: mod определён только для Integer");
+    };
+    if y.is_zero() {
+        return refuse("остаток от деления на ноль — evaluation error (§58)");
+    }
+    let m = y.abs();
+    let r = ((&x % &m) + &m) % &m;
+    Ok(Val::Dec { u: r, s: 0 })
+}
+
+pub fn min(a: &Val, b: &Val) -> R<Val> {
+    same(a, b, "min")?;
+    let (x, y, _) = pair(a, b);
+    Ok(if x <= y { a.clone() } else { b.clone() })
+}
+
+pub fn max(a: &Val, b: &Val) -> R<Val> {
+    same(a, b, "max")?;
+    let (x, y, _) = pair(a, b);
+    Ok(if x >= y { a.clone() } else { b.clone() })
+}
+
+pub fn abs(v: &Val) -> R<Val> {
+    let Some((u, s, _)) = num(v) else {
+        return refuse("§58: abs — не числовой вид");
+    };
+    Ok(mk(u.abs(), s, v))
+}
+
+/// §58 (E-0075): только Integer pow Integer; порядок проверок — знак, предел,
+/// вычисление, диапазон — часть контракта.
+pub fn pow(base: &Val, exp: &Val) -> R<Val> {
+    let (Some(x), Some(e)) = (integral(base), integral(exp)) else {
+        return refuse("§58: pow определён только для Integer");
+    };
+    if e.is_negative() {
+        return refuse("§58: pow — показатель отрицателен");
+    }
+    if e > BigInt::from(4096) {
+        return refuse("RESOURCE_LIMIT: pow — показатель превышает 4096");
+    }
+    let r = num_traits::pow(x, e.to_usize().unwrap());
+    if r < BigInt::from(i64::MIN) || r > BigInt::from(i64::MAX) {
+        return refuse("RESOURCE_LIMIT: pow — результат вне 64-битного диапазона");
+    }
+    Ok(Val::Dec { u: r, s: 0 })
+}
+
+pub fn round(m: &Val, digits: &Val, mode: &str) -> R<Val> {
+    if mode != "HALF_UP" {
+        return refuse(format!("§50: режим округления не реализован: {mode}"));
+    }
+    let Some((mu, ms, _)) = num(m) else {
+        return refuse("§50: round — не числовой вид");
+    };
+    let n = match num(digits) {
+        Some((du, ds, _)) => (du / p10(ds)).to_usize().unwrap_or(0),
+        None => 0,
+    };
+    if ms <= n {
+        return Ok(mk(mu * p10(n - ms), n, m));
+    }
+    let drop = p10(ms - n);
+    let neg = mu.is_negative();
+    let a = mu.abs();
+    let (q, r) = a.div_rem(&drop);
+    let up = if r * 2 >= drop { q + 1 } else { q }; // HALF_UP — от нуля
+    Ok(mk(if neg { -up } else { up }, n, m))
+}
+
+// --- сравнение и равенство ---------------------------------------------------
+
+fn ordered(op: &str, c: std::cmp::Ordering) -> R<bool> {
+    use std::cmp::Ordering::*;
+    Ok(match op {
+        "lt" => c == Less,
+        "le" => c != Greater,
+        "gt" => c == Greater,
+        "ge" => c != Less,
+        "eq" => c == Equal,
+        "ne" => c != Equal,
+        _ => return refuse(format!("сравнение вне среза рантайма: {op}")),
+    })
+}
+
+pub fn cmp(a: &Val, op: &str, b: &Val) -> R<bool> {
+    if let (Val::Sym(x), Val::Sym(y)) = (a, b) {
+        return match op {
+            "eq" => Ok(x == y),
+            "ne" => Ok(x != y),
+            _ => refuse("§57: вид enum не упорядочен"),
+        };
+    }
+    if matches!(a, Val::Sym(_)) || matches!(b, Val::Sym(_)) {
+        return match op {
+            "eq" => Ok(false),
+            "ne" => Ok(true),
+            _ => refuse("§57: вид enum не упорядочен"),
+        };
+    }
+    if let (Val::Date(x), Val::Date(y)) = (a, b) {
+        return ordered(op, x.cmp(y));
+    }
+    if matches!(a, Val::Date(_)) || matches!(b, Val::Date(_)) {
+        return match op {
+            "eq" => Ok(false),
+            "ne" => Ok(true),
+            _ => refuse("§57: Date сравнивается только с Date"),
+        };
+    }
+    if matches!(a, Val::Text(_)) || matches!(b, Val::Text(_)) {
+        let same_text = matches!((a, b), (Val::Text(x), Val::Text(y)) if x == y);
+        return match op {
+            "eq" => Ok(same_text),
+            "ne" => Ok(!same_text),
+            _ => refuse(format!("порядок на Text вне среза рантайма: {op}")),
+        };
+    }
+    let (Some((_, _, ca)), Some((_, _, cb))) = (num(a), num(b)) else {
+        return refuse(format!("сравнение вне среза рантайма: {op}"));
+    };
+    if ca.is_some() != cb.is_some() {
+        return refuse("§49: сравнение денег с безразмерным");
+    }
+    if ca.is_some() && ca != cb {
+        return refuse("§49: разные валюты");
+    }
+    let (x, y, _) = pair(a, b);
+    ordered(op, x.cmp(&y))
+}
+
+pub fn eq(a: &Val, b: &Val) -> bool {
+    match (a, b) {
+        (Val::Sym(x), Val::Sym(y)) => x == y,
+        (Val::Sym(_), _) | (_, Val::Sym(_)) => false,
+        (Val::Date(x), Val::Date(y)) => x == y,
+        (Val::Date(_), _) | (_, Val::Date(_)) => false,
+        (Val::Text(x), Val::Text(y)) => x == y,
+        (Val::Text(_), _) | (_, Val::Text(_)) => false,
+        _ => {
+            let (Some((_, _, ca)), Some((_, _, cb))) = (num(a), num(b)) else { return false };
+            if ca.is_some() != cb.is_some() || ca != cb {
+                return false;
+            }
+            let (x, y, _) = pair(a, b);
+            x == y
+        }
+    }
+}
+
+fn norm(u: &BigInt, s: usize) -> String {
+    let mut u = u.clone();
+    let mut s = s;
+    let ten = BigInt::from(10);
+    while s > 0 && (&u % &ten).is_zero() {
+        u /= &ten;
+        s -= 1;
+    }
+    format!("{u}e-{s}")
+}
+
+/// Разделитель и экран внутри текста экранируются: иначе ["a|e:b","c"] и
+/// ["a","b|e:c"] склеивались в один ключ, и второй факт терялся.
+fn esc(t: &str) -> String {
+    t.replace('\\', "\\\\").replace('|', "\\|")
+}
+
+pub fn key(row: &[Val]) -> String {
+    row.iter()
+        .map(|v| match v {
+            Val::Text(t) => format!("e:{}", esc(t)),
+            Val::Date(d) => format!("t:{d}"),
+            Val::Sym(s) => format!("c:{}", esc(s)),
+            Val::Money { u, s, cur } => format!("m:{cur}:{}", norm(u, *s)),
+            Val::Dec { u, s } => format!("d:{}", norm(u, *s)),
+        })
+        .collect::<Vec<_>>()
+        .join("|")
+}
+
+// --- таблицы и правовое время -----------------------------------------------
+
+/// Таблицы фактов в порядке объявления и ключи виденных строк (§211: порядок
+/// обхода детерминирован — векторы, не множества).
+pub struct Db {
+    pub tables: Vec<(String, Vec<Vec<Val>>)>,
+    seen: BTreeSet<String>,
+    legal_time: String,
+}
+
+impl Db {
+    pub fn new(preds: &[&str]) -> Db {
+        Db {
+            tables: preds.iter().map(|p| (p.to_string(), Vec::new())).collect(),
+            seen: BTreeSet::new(),
+            legal_time: String::new(),
+        }
+    }
+
+    pub fn rows(&self, pred: &str) -> &[Vec<Val>] {
+        self.tables
+            .iter()
+            .find(|(p, _)| p == pred)
+            .map(|(_, rows)| rows.as_slice())
+            .unwrap_or(&[])
+    }
+
+    pub fn has(&self, pred: &str) -> bool {
+        self.tables.iter().any(|(p, _)| p == pred)
+    }
+
+    pub fn add(&mut self, pred: &str, row: Vec<Val>) -> bool {
+        let k = format!("{pred}#{}", key(&row));
+        if !self.seen.insert(k) {
+            return false;
+        }
+        if let Some((_, rows)) = self.tables.iter_mut().find(|(p, _)| p == pred) {
+            rows.push(row);
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn set_legal_time(&mut self, t: &str) {
+        self.legal_time = t.to_string();
+    }
+
+    pub fn legal_time(&self) -> R<String> {
+        if self.legal_time.is_empty() {
+            return refuse("legalTime не подан делом");
+        }
+        Ok(self.legal_time.clone())
+    }
+}

arxo_codegen/targets/scala/Cert.scala

@@ -0,0 +1,77 @@
+// Харнесс сертификации рантайма: исполняет runtime-cert.json и печатает,
+// что получилось. Ожидания сверяют ворота, харнесс их не читает.
+object Cert {
+  sealed trait Arg
+  final case class S(s: String) extends Arg
+  final case class Val(v: V) extends Arg
+  final case class Row(r: Vector[V]) extends Arg
+
+  def lit(x: J): Arg = x match {
+    case JStr(s) => S(s)
+    case _ if x("dec").str.isDefined => Val(RT.dec(x("dec").text))
+    case _ if x("money").str.isDefined => Val(RT.money(x("money").text, x("cur").text))
+    case _ if x("text").str.isDefined => Val(Txt(x("text").text))
+    case _ if x("date").str.isDefined => Val(RT.date(x("date").text))
+    case _ if x("sym").str.isDefined => Val(RT.sym(x("sym").text))
+    case _ if x("row") != JNull => Row(x("row").items.map(c => lit(c) match {
+      case Val(v) => v
+      case other => throw new IllegalStateException(s"ячейка фикстуры: $other")
+    }))
+    case _ => throw new IllegalStateException(s"литерал фикстуры: $x")
+  }
+
+  // Отображение с ЯВНЫМ масштабом: 2.00 и 2 — разные записи одного значения.
+  def digits(u: BigInt, s: Int): String = {
+    val body0 = u.abs.toString
+    val body = "0" * math.max(0, s + 1 - body0.length) + body0
+    val text = if (s == 0) body else body.dropRight(s) + "." + body.takeRight(s)
+    (if (u < 0) "-" else "") + text
+  }
+
+  def render(v: V): String = v match {
+    case Txt(t) => Json.str(t)
+    case Money(u, s, cur) => Json.str(digits(u, s) + " " + cur)
+    case Dec(u, s) => Json.str(digits(u, s))
+    case LDate(d) => Json.str(d)
+    case Sym(id) => Json.str(id)
+  }
+
+  def v(a: Arg): V = a match { case Val(x) => x; case S(s) => Txt(s); case _ => throw new IllegalStateException("значение") }
+  def s(a: Arg): String = a match { case S(x) => x; case _ => throw new IllegalStateException("строка") }
+  def row(a: Arg): Vector[V] = a match { case Row(r) => r; case _ => throw new IllegalStateException("строка таблицы") }
+
+  def run(op: String, a: Vector[Arg]): String = op match {
+    case "dec" => render(RT.dec(s(a(0))))
+    case "money" => render(RT.money(s(a(0)), s(a(1))))
+    case "date" => render(RT.date(s(a(0))))
+    case "sym" => render(RT.sym(s(a(0))))
+    case "mul" => render(RT.mul(v(a(0)), v(a(1))))
+    case "add" => render(RT.add(v(a(0)), v(a(1))))
+    case "sub" => render(RT.sub(v(a(0)), v(a(1))))
+    case "div" => render(RT.div(v(a(0)), v(a(1))))
+    case "mod" => render(RT.mod(v(a(0)), v(a(1))))
+    case "min" => render(RT.min(v(a(0)), v(a(1))))
+    case "max" => render(RT.max(v(a(0)), v(a(1))))
+    case "abs" => render(RT.abs(v(a(0))))
+    case "pow" => render(RT.pow(v(a(0)), v(a(1))))
+    case "round" => render(RT.round(v(a(0)), v(a(1)), s(a(2))))
+    case "cmp" => RT.cmp(v(a(0)), s(a(1)), v(a(2))).toString
+    case "eq" => RT.eq(v(a(0)), v(a(1))).toString
+    case "keyEq" => (RT.key(row(a(0))) == RT.key(row(a(1)))).toString
+    case "legalTime" => Json.str(RT.legalTime())
+    case "setLegalTime" => RT.setLegalTime(s(a(0))); "null"
+    case other => throw new IllegalStateException(s"неизвестная операция фикстуры: $other")
+  }
+
+  def main(argv: Array[String]): Unit = {
+    val fixture = Json.read(argv(0))
+    val out = fixture("cases").items.map { c =>
+      val got =
+        try run(c("op").text, c("args").items.map(lit))
+        catch { case e: Refused => "{\"refused\":" + Json.str(e.getMessage) + "}" }
+      "{\"id\":" + Json.str(c("id").text) + ",\"got\":" + got + "}"
+    }
+    Json.out.println(out.mkString("[", ",", "]"))
+    Json.out.flush()
+  }
+}

arxo_codegen/targets/scala/Json.scala

@@ -0,0 +1,140 @@
+// Разбор JSON для Scala: в стандартной библиотеке его нет. Число хранится
+// исходной записью (JNum), двоичная плавающая точка его не видит. Печать —
+// байтами UTF-8 явно: кодировка System.out берётся из локали, и в контейнере
+// с POSIX-локалью кириллица отказа вышла бы вопросами.
+import java.io.{FileDescriptor, FileOutputStream, PrintStream}
+import java.nio.charset.StandardCharsets
+import java.nio.file.{Files, Paths}
+
+sealed trait J {
+  def apply(k: String): J = this match {
+    case JObj(m) => m.getOrElse(k, JNull)
+    case _ => JNull
+  }
+  def items: Vector[J] = this match {
+    case JArr(a) => a
+    case _ => Vector.empty
+  }
+  /** Текст значения: строка как есть, число — его запись, иначе пусто. */
+  def text: String = this match {
+    case JStr(s) => s
+    case JNum(t) => t
+    case JBool(b) => b.toString
+    case _ => ""
+  }
+  def str: Option[String] = this match {
+    case JStr(s) => Some(s)
+    case _ => None
+  }
+}
+case object JNull extends J
+final case class JBool(b: Boolean) extends J
+final case class JNum(t: String) extends J
+final case class JStr(s: String) extends J
+final case class JArr(a: Vector[J]) extends J
+final case class JObj(m: Map[String, J]) extends J
+
+object Json {
+  val out = new PrintStream(new FileOutputStream(FileDescriptor.out), true, "UTF-8")
+
+  def read(path: String): J = parse(new String(Files.readAllBytes(Paths.get(path)), StandardCharsets.UTF_8))
+
+  def parse(s: String): J = {
+    var i = 0
+    def fail(what: String): Nothing = throw new IllegalArgumentException(s"JSON: $what в позиции $i")
+    def ws(): Unit = while (i < s.length && " \t\r\n".indexOf(s.charAt(i)) >= 0) i += 1
+    def string(): String = {
+      i += 1
+      val sb = new StringBuilder
+      while (true) {
+        if (i >= s.length) fail("строка не закрыта")
+        val c = s.charAt(i)
+        if (c == '"') { i += 1; return sb.toString }
+        if (c == '\\') {
+          val e = s.charAt(i + 1)
+          i += 2
+          e match {
+            case '"' | '\\' | '/' => sb.append(e)
+            case 'b' => sb.append('\b')
+            case 'f' => sb.append('\f')
+            case 'n' => sb.append('\n')
+            case 'r' => sb.append('\r')
+            case 't' => sb.append('\t')
+            // Суррогатные пары складываются сами: строка JVM — UTF-16.
+            case 'u' => sb.append(Integer.parseInt(s.substring(i, i + 4), 16).toChar); i += 4
+            case _ => fail("плохой экран")
+          }
+        } else { sb.append(c); i += 1 }
+      }
+      ""
+    }
+    def value(): J = {
+      ws()
+      if (i >= s.length) fail("конец входа")
+      s.charAt(i) match {
+        case '{' =>
+          i += 1
+          val b = Map.newBuilder[String, J]
+          ws()
+          if (s.charAt(i) == '}') { i += 1; return JObj(Map.empty) }
+          while (true) {
+            ws()
+            if (s.charAt(i) != '"') fail("ожидался ключ")
+            val k = string()
+            ws()
+            if (s.charAt(i) != ':') fail("ожидалось ':'")
+            i += 1
+            b += (k -> value())
+            ws()
+            val d = s.charAt(i)
+            i += 1
+            if (d == '}') return JObj(b.result())
+            if (d != ',') fail("ожидалось ',' или '}'")
+          }
+          JNull
+        case '[' =>
+          i += 1
+          val b = Vector.newBuilder[J]
+          ws()
+          if (s.charAt(i) == ']') { i += 1; return JArr(Vector.empty) }
+          while (true) {
+            b += value()
+            ws()
+            val d = s.charAt(i)
+            i += 1
+            if (d == ']') return JArr(b.result())
+            if (d != ',') fail("ожидалось ',' или ']'")
+          }
+          JNull
+        case '"' => JStr(string())
+        case _ if s.startsWith("true", i) => i += 4; JBool(true)
+        case _ if s.startsWith("false", i) => i += 5; JBool(false)
+        case _ if s.startsWith("null", i) => i += 4; JNull
+        case _ =>
+          val start = i
+          while (i < s.length && "+-.eE0123456789".indexOf(s.charAt(i)) >= 0) i += 1
+          if (start == i) fail("неизвестное значение")
+          JNum(s.substring(start, i))
+      }
+    }
+    val v = value()
+    ws()
+    if (i != s.length) fail("лишнее после значения")
+    v
+  }
+
+  /** Строка JSON: символы как есть, экранируются кавычка, экран и управляющие. */
+  def str(s: String): String = {
+    val sb = new StringBuilder("\"")
+    s.foreach {
+      case '"' => sb.append("\\\"")
+      case '\\' => sb.append("\\\\")
+      case '\n' => sb.append("\\n")
+      case '\r' => sb.append("\\r")
+      case '\t' => sb.append("\\t")
+      case c if c < 0x20 => sb.append("\\u%04x".format(c.toInt))
+      case c => sb.append(c)
+    }
+    sb.append('"').toString
+  }
+}