SVI Пересмотр документации

docs/docs/01_30.md

@@ -31,30 +31,36 @@
 
 Пример:
 
-```yml
-прц:
-  имя: ОбработатьДанные
-  парам:
-      - СписокБайт данные +изм
+```python
+прц(
+  имя(ОбработатьДанные)
+  парам(
+    СписокБайт(нов данные +изм)
+  )
   # высокоуровневая композиция
-  нач:
-    - ФильтроватьДанные данные
-    - Сравнить рез > 10
-    - ФнКвадрат
-    - .. рез
+  нач(
+    ФильтроватьДанные(данные)
+    Сравнить(рез > 10)
+    ФнКвадрат
+    ..(рез)
+  )
+)
 ```
 
-```yml
+```python
 # при необходимости — ручное управление
-прц:
-    имя: КопироватьПамять
-    эффект:
-        - система
-    парам:
-        - СисАдр источник +изм цель +изм
-        - СисРазмер размер
-    асм:
-        - ПовторОтДо источник цель
+прц(
+    имя(КопироватьПамять)
+    эффект(система)
+    парам(
+      СисАдр(нов источник +изм)
+      СисАдр(нов цель +изм)
+      СисРазмер(нов размер)
+    )
+    асм(
+      ПовторОтДо(источник цель)
+    )
+)
 ```
 
 Философский смысл:
@@ -96,32 +102,42 @@
 - С явным комментарием причины (автоматически включается в документацию),
 - С обязательным тестированием.
 
-```yml
+```python
 # Функции никогда ничего не изменяют
-фн:
-  имя: СложитьДист1
-  парам:
-    - Км a
-    - М b
-  вых:
-    - Км рез
-  нач:
-    - СложитьКмМ a b
-    - .. рез
+фн(
+  имя(СложитьДист1)
+  парам(
+    Км(нов a)
+    М(нов b)
+  )
+  вых(
+    Км(нов рез)
+  )
+  нач(
+    СложитьКмМ(a b)
+    ..(рез)
+  )
+)
+
 
 # Процессы могут, но не обязаны иметь побочные эффекты
-прц:
-  имя: ЗначПоАдр
-  эффект:
-    - система
-    - драйвер "взаимодействие с менджером памяти"
-    парам:
-      Адр: адр +изм
-    вых:
-      - Адр рез
-    нач:
-      - ЗначИз адр
-      - .. рез
+прц(
+  имя(ЗначПоАдр)
+  эффект(
+    система()
+    драйвер("взаимодействие с менджером памяти")
+  )
+    парам(
+      Адр(нов адр +изм)
+    )
+    вых(
+      Адр(нов рез)
+    )
+    нач(
+      ЗначИз(адр)
+      ..(рез)
+    )
+)
 ```
 
 Философский смысл:
@@ -206,42 +222,57 @@
 
 Пример:
 
-```yml
+```python
 # тип выведен: Целое
 #    эффект +изм — если не указано то неизменяемо
-прц:
-  имя: Пуск
-  нач:
-    - Рубль нов 42
-    - уст х
+прц(
+  имя(Пуск)
+  нач(
+    Рубль(нов 42)
+    уст(х)
+  )
+)
+
 
 # явная динамика — только при необходимости
 #    тип нечто — определяется как СрезБайт
-прц:
-  имя: Пуск
-  эффект:
-    - нечто
-  нач:
-   - ПолучитьИзВнешнегоАпи
-   - уст нечто
+прц(
+  имя(Пуск)
+  эффект(
+    нечто()
+  )
+  нач(
+    ПолучитьИзВнешнегоАпи()
+    уст(нечто)
+  )
+)
+
 
 # но в блоке безопасности — только статика
-фн:
-  имя: ПроверитьДоступ
-  эффект:
-    - нечто
-  парам:
-    - Пользователь пользователь +изм
-    - Роль         роль +изм
-  вых:
-    - Пользователь рез
-  нач:
-   - ЕслиНечто нечто
-   - Пользователь изБайт нечто
-   # динамические типы запрещены здесь
-   - если рез .еслиОш
-   - _ тогда Паника "ПроверитьДоступ: кривые данные для пользователя"
-   - .. рез .знач
+фн(
+  имя(ПроверитьДоступ)
+  эффект(
+    нечто()
+  )
+  парам(
+    Пользователь(нов пользователь +изм)
+    Роль(нов роль +изм)
+  )
+  вых(
+    Пользователь(нов рез)
+  )
+  нач(
+    ЕслиНечто(нечто)
+    Пользователь(изБайт нечто)
+    # динамические типы запрещены здесь
+    если (рез(.еслиОш)
+      тогда (
+        Паника("ПроверитьДоступ: кривые данные для пользователя")
+      )
+    )
+    ..(рез(.знач))
+  )
+)
 ```
 
 Философский смысл:

docs/docs/01_40.md

@@ -53,33 +53,51 @@
 
 Вариант 1: Явный блок низкоуровневый с контекстным предупреждением
 
-```yml
-прц:
-  имя: ОбработатьДанные
-  парам:
-    - СписокБайт вход +изм
-  вых:
-    - СписокБайт
-  нач:
+```python
+прц(
+  имя(ОбработатьДанные)
+  парам(
+    СписокБайт(нов вход +изм)
+  )
+  вых(
+    СписокБайт(нов рез)
+  )
+  нач(
     # Высокий уровень — чисто, безопасно)
-    - ФильтрПо вход > 10
-    - СписокБайт * рез 2
-    - .. рез
+    ФильтрПо(вход > 10)
+    СписокБайт(* рез 2)
+    ..(рез)
+  )
+)
+
 
 # Внимание! Здесь действуют другие законы
-прц:
-  имя: СкопироватьПамять
-  эффект:
-    - система
-    - квалификация 3
-    - одобрение нужно
-  парам:
-    - Байт источник цель
-    - СбщДлина длина
-    нач:
+прц(
+  имя(СкопироватьПамять)
+  эффект(
+    система()
+    квалификация(3)
+    одобрение(нужно)
+  )
+  парам(
+    Байт(нов источник)
+    Байт(нов цель)
+    СбщДлина(нов длина)
+  )
+  нач(
       # Прямое обращение к памяти в цикле
-      - Цикл от 0 до длина
-      - _ ПрцКварк рез
+      Знач(0)
+      уст(нач)
+      Знач(50)
+      уст(длина)
+      Цикл(
+        ЦиклСтоп(нач >= длина)
+        ПрцКварк(рез)
+        Цел(инк нач)
+      )
+  )
+)
+
 ```
 
 Психологические преимущества:
@@ -96,36 +114,49 @@
 
 Вариант 2: Модульный подход с уровнем доступа
 
-```yml
-модуль:
-  имя: БезопаснаяОбработка
-  прц:
-    имя: Фильтровать
-    парам:
-      - ДанныеПоток данные +изм
-    вых:
-      - ДанныеПоток
-    нач:
-        - Сравнить данные .длина > 10
-        - если рез
-        - _ тогда ДобСписок данные
-        - .. рез
+```python
+модуль(
+  имя(БезопаснаяОбработка)
+  прц(
+    имя(Фильтровать)
+    парам(
+      ДанныеПоток(нов данные +изм)
+    )
+    вых(
+      ДанныеПоток(нов рез)
+    )
+    нач(
+      Сравнить(данные(.длина) > 10)
+      если (рез
+        тогда(
+          ДобСписок(данные)
+        )
+      )
+      ..(рез)
+    )
+  )
+)
+
 
 # Только для программистов с уровнем > 3, специалист
-модуль:
-  имя: НизкоуровневаяОптимизация
-  эффект:
-    - компетенция 4
-  импорт:
-        - Ядро.Память
-        - Ядро.Асм
-  фн:
-    имя: фнКопироватьБыстро
-    эффект:
-      система
-    нач:
-      -...
-      -...
+модуль(
+  имя(НизкоуровневаяОптимизация)
+  эффект(
+    компетенция(4)
+  )
+  импорт(
+    Ядро(нов Память)
+    Ядро(нов Асм)
+  )
+  фн(
+    имя(фнКопироватьБыстро)
+    эффект(система)
+    нач(
+      ...
+      ...
+    )
+  )
+)
 ```
 
 ### Градации программистов
@@ -171,36 +202,43 @@
 
 Вариант 3: Гибридный синтаксис с "прозрачным спуском"
 
-```yml
-прц:
-  имя: ЦелКопияИнк
-  эффект:
-    - кварк
-  парам:
-    - Целое вх
-  вых:
-    - Целое
-  нач:
-    - Цел копия вх х1
-    - Цел инк рез
-    - .. рез
-
-прц:
-  имя: ОбработатьГруппу
-  эффект:
-    - уровень_ниже
-  парам:
-    - ПолучитьДанные данные
-  нач:
+```python
+прц(
+  имя(ЦелКопияИнк)
+  эффект(кварк())
+  парам(
+    Цел(нов вх)
+  )
+  вых(
+    Цел(нов рез)
+  )
+  нач(
+    Цел(копия вх х1)
+    Цел(инк рез)
+    ..(рез)
+  )
+)
+
+
+
+прц(
+  имя(ОбработатьГруппу)
+  эффект(уровень_ниже())
+  парам(
+    ПолучитьДанные(данные)
+  )
+  нач(
     # Высокий уровень
-    - ГруппироватьПо данные .ключ
-    - уст группа
-    - СуммироватьПо данные .группа
+    ГруппироватьПо(данные(.ключ))
+    уст(группа)
+    СуммироватьПо(данные(.группа))
     # Спуск в низкий уровень — через вызов функции/процесса в которых указананы эффекты
     # Теперь можно использовать указатели, asm)
-    - ЦелКопияИнк рез
+    ЦелКопияИнк(рез)
     # Подъём автоматически
-    - .. рез
+    ..(рез)
+  )
+)
 ```
 
 Особенности:
@@ -219,22 +257,32 @@
 
 Вариант 4: Интеграция с системой обучения (обучающий компилятор)
 
-```yml
-прц:
-  имя: ОбработатьПамять
-  эффект:
-    - система
-  парам:
-    - Срез.Байт размер
-  вых:
-    - АсмИмя
+```python
+прц(
+  имя(ОбработатьПамять)
+  эффект(система)
+  парам(
+    СрезБайт(нов размер)
+  )
+  вых(
+    АсмИмя(рез)
     # Компилятор замечает:  "Вы используете сырые указатели"
-  нач:
-    - Компилятор сравнить уровень < 3
-    - Компилятор если рез
-    - _ тогда ПройтиМодуль "Управление памятью (5 мин)"
-    - _ иначе ИспользоватьБезопасныйАналог "БуферБайт"
-    - .. рез
+  )
+  нач(
+    Компилятор(срав уровень < 3)
+    Компилятор(
+      если(рез
+        тогда(
+          ПройтиМодуль("Управление памятью (5 мин)")
+        )
+        иначе(
+          ИспользоватьБезопасныйАналог("БуферБайт")
+        )
+      )
+    )
+    ..(рез)
+  )
+)
 ```
 
 Реализация:

docs/docs/01_50.md

@@ -221,58 +221,77 @@
 
 ### Гибридная структура с явной границей
 
-```yml
+```python
 # Высокий уровень — по умолчанию
-прц:
-  имя: Обработать
-  парам:
-    - СписокБайт данные +изм
-  вых:
-    - СписокБайт
-  нач:
-    - Фильтровать данные
-    - _ > 10
-    - _ * 2
-    - .. рез
+прц(
+  имя(Обработать)
+  парам(
+    СписокБайт(нов данные +изм)
+  )
+  вых(
+    СписокБайт(нов вых)
+  )
+  нач(
+    Фильтровать(данные
+      (_ > 10)
+      (_ * 2)
+    )
+    ..(рез)
+  )
 )
 
 # Низкий уровень — только явно, с контекстом
-фн:
-  имя: Копировать
-  эффект:
-    - система
-  парам:
-    - Байт источник цель
-  нач:
+фн(
+  имя(Копировать)
+  эффект(
+    система()
+  )
+  парам(
+    Байт(нов источник)
+    Байт(нов цель)
+  )
+  нач(
     # Прямой доступ
-    - Кварк ....
+    Кварк(....)
+  )
+)
+
 ```
 
 ### Язык может дополнять себя (по образцу Lisp)
 
-```yml
-макрос:
-  имя: Асинх
-  эффект:
-    - асинх
-  парам:
-   - Стр тело
-  нач:
+```python
+макрос(
+  имя(Асинх)
+  эффект(
+    асинх()
+  )
+  парам(
+    Стр(нов тело)
+  )
+  нач(
     # Трансформация в state machine
-    - Печать "генерировать_конечный_автомат{тело}"
+    Печать("генерировать_конечный_автомат{тело}")
+  )
+)
 
 # Использование:
-прц:
-  имя: Пуск
-  эффект:
-    - асинх
-  парам:
-    - СписокБайт данные
-  нач:
+прц(
+  имя(Пуск)
+  эффект(
+    асинх()
+  )
+  парам(
+    СписокБайт(нов данные)
+  )
+  нач(
     # Внутри вызова: определение "нечто"
-    - ОжидатьЗапрос
-    - уст данные
-    - ОбработатьДанные данные
+    ОжидатьЗапрос
+    уст(данные)
+    ОбработатьДанные(данные)
+  )
+)
+
 ```
 
 Язык не статичен — он развивается в процессе использования.

docs/docs/01_55.md

@@ -1,6 +1,6 @@
 # pro.01_55 Диалектика формы языка программирования
 
-В качестве базовой реализации языка программирования **prolet** принята форма заключение всех сущностей в `YAML`. На первом месте стоит контекст, имеющий смысл "в заданных границах исполни действие в блоке". Единственная форма, не имеющая контекста -- одиночная точка: контекст отменяющий результат (см. далее).
+В качестве базовой реализации языка программирования **prolet** принята форма заключение всех сущностей в `TOF`. На первом месте стоит контекст, имеющий смысл "в заданных границах исполни действие в блоке". Единственная форма, не имеющая контекста -- одиночная точка: контекст отменяющий результат (см. далее).
 
 Синтаксис закрепляет онтологический принцип в форме языка.
 
@@ -17,8 +17,10 @@
 
 Форма:
 
-```text
-<контекст>  <возможно_действие>  <возможно_аргументы>
+```python
+<контекст>(
+  <возможно_действие>(<возможно_аргументы>)
+  )
 ```
 
 выражает единство формы и содержания:
@@ -34,10 +36,10 @@
 
 Контекст — не синтаксическое украшение, он — руководящее начало, идеологический центр процесса.
 
-- `фн: ...` -- контекст декларации (организация труда по преобразованию, труд через установление порядка);
-- `атом: ...` -- контекст декларации (организация протонов и нейтронов, создание сложных форм материи);
-- `если ...` -- контекст применения (поиск сущего в практике, реализация диалектики бытия);
-- `- система` -- эффект, задающий условия существования предельно конкретной истины, ограничивает границы возможного конкретного предметного труда
+- `фн(...)` -- контекст декларации (организация труда по преобразованию, труд через установление порядка);
+- `атом(...)` -- контекст декларации (организация протонов и нейтронов, создание сложных форм материи);
+- `если(...)` -- контекст применения (поиск сущего в практике, реализация диалектики бытия);
+- `- система()` -- эффект, задающий условия существования предельно конкретной истины, ограничивает границы возможного конкретного предметного труда
 
 > 💡 **Контекст** — это границы процесса и руководящая роль в процессе, его пространство возможного: как управляющий центр организует ресурсы, руководит исполнением, контролирует процесс и определяет форму результата процесса, но не конкретный результат процесса.
 
@@ -64,47 +66,66 @@
 
 ## Единая форма для всех процессов — отражение единства бытия
 
-Отказ от множества синтаксисов (как в `Rust`, `Pascal`, `Python`) в пользу единой формы `%контекст: ...` — это пример диалектического решения.
+Отказ от множества синтаксисов (как в `Rust`, `Pascal`, `Python`) в пользу единой формы `%контекст(...)` — это пример диалектического решения.
 
 ### Вычисление
 
 ```yml
-фн:
-  имя: CложитьКм
-  парам:
-    - Км a b
-  вых:
-    - Км
-  нач:
-    - Км слож a b
-    - .. рез
+фн(
+  имя(CложитьКм)
+  парам(
+    Км(нов a)
+    Км(нов b)
+  )
+  вых(
+    Км(нов рез)
+  )
+  нач(
+    Км(слож a b)
+    ..(рез)
+  );
+);
 ```
 
 ## Определение атома (структуры)
 
-```yml
-атом:
-  имя: Пользователь
-  протон:
-    - Имя     имя     +эксп
-    - Возраст возраст
+```python
+атом(
+  имя(Пользователь)
+  протон(
+    Имя(нов имя +эксп)
+    Возраст(нов возраст)
+  );
+);
 ```
 
 ## Условие
 
-```yml
-нач:
-  - Цел срав x > 0
-  - если рез
-  - _ тогда Напечатать "положительно")
+```python
+нач(
+  Цел(срав x > 0)
+  если (рез
+    тогда(
+      Напечатать("положительно")
+    )
+  )
+)
 ```
 
 ## Цикл
 
-```yml
-нач:
- - Цикл Данные шаг 2 Цел удвоить рез
- - ОтправитьПоПочте рез
+```python
+нач(
+  Цел(нов 0)
+  уст(итер)
+  Цикл(
+      Цел(*2 рез)
+      Цел(+ итер 2)
+      Цел(срав итер 20)
+      ЦиклСтоп(рез)
+  );
+  ОтправитьПоПочте(рез);
+);
 ```
 
 ## Диалектический процесс творчества
@@ -135,7 +156,7 @@
 
 Даже комментарий — является процессом:
 
-```yml
+```python
 # Этот модуль отвечает за безопасность пользователей
 ```
 
@@ -158,19 +179,25 @@
 
 Новый тип контекста — новая форма организации труда. Пример:
 
-```yml
-прц:
-  имя: Пуск +эксп
-  нач:
-    - ПрцПарал ОбогатитьДанные
-    - Загрузить
-    - Индексировать
-
-прц:
-  имя: ОбновитьСчёт
-  нач:
-    - ОбновитьСчёт
-    - ОтправитьУведомление
+```python
+прц(
+  имя(Пуск +эксп)
+  нач(
+    ПрцПарал(
+      ОбогатитьДанные()
+      Загрузить()
+      Индексировать()
+    )
+  )
+)
+
+прц(
+  имя(ОбновитьСчёт)
+  нач(
+    ОбновитьСчёт()
+    ОтправитьУведомление()
+  )
+)
 ```
 
 Язык не растёт за счёт синтаксиса, а за счёт семантики контекстов.

docs/docs/01_60.md

@@ -39,8 +39,8 @@
 
 Вместо множества форм ( `struct` , `enum` , `fn` , `unsafe` , `impl` , `where` и т.д.) — одна базовая конструкция:
 
-```yml
-%контекст: ...
+```pyton
+%контекст(...)
 ```
 
 **Но!** Семантика определяется *не формой*, а *контекстом* и *свойствами контекста*.
@@ -48,72 +48,106 @@
 Примеры:
 Функция (высокий уровень)
 
-```yml
-фн:
-  имя: Обработать
-  парам:
-    - Байты данные
-  нач:
-    - Фильтровать данные (> 10) (* 2)
+```python
+фн(
+  имя(Обработать)
+  парам(
+    Байты(нов данные)
+  )
+  нач(
+    Фильтровать(данные
+      (> 10)
+      (* 2)
+    )
+  )
+)
+
 ```
 
 Низкоуровневая операция
 
-```yml
-прц:
-  имя: ЦелПеремещ
-  эффект:
-    - система
-    - кварк
-  парам:
-    - КваркЦел ист цель +изм
-  нач:
-    - Загр ист рег0
-    - Слож рег1 рег0
-    - Сохр рег1 цель
-
-прц:
-  имя: Копировать
-  парам:
-    - CисАдрес ист цель
-    - Дом размер
-  нач:
-    - Цикл ист до цель ЦелПеремещ рез
+```python
+прц(
+  имя(ЦелПеремещ)
+  эффект(
+    система()
+    кварк()
+  )
+
+  парам(
+    КваркЦел(нов ист)
+    КваркЦел(нов цель +изм)
+  )
+  нач(
+    Загр(ист рег0)
+    Слож(рег1 рег0)
+    Сохр(рег1 цель)
+  )
+)
+
+
+прц(
+  имя(Копировать)
+  парам(
+    CисАдрес(нов ист)
+    СисАдрес(нов цель)
+    Дом(нов размер)
+  )
+  нач(
+    Цикл(
+      ЦелПеремещ(рез)
+      СисАдр(инк ист)
+      СисАдр(срав ист цель)
+      ЦиклСтоп(рез)
+    );
+  );
+);
+
 ```
 
 ### Атомы
 
-```yml
-атом:
-  имя: Пользователь
-  протон:
-    - ЧеловекНом     номер
-    - ЧеловекИмя     имя     +изм
-    - ЧеловекВозраст возраст +изм
-    - Роль           роль    +изм
+```python
+атом(
+  имя(Пользователь)
+  протон(
+    ЧеловекНом(нов номер)
+    ЧеловекИмя(нов имя +изм)
+    ЧеловекВозраст(нов возраст +изм)
+    Роль(нов роль +изм)
+  )
+)
+
 ```
 
 Спецификация
 
-```yml
-спец:
-  имя: ИФайл
-  действ:
-    Читать:
-      тип: прц
-      парам:
-        - ФайлИмя имя
-      вых:
-        - РезБайты
-      док: "Читает файл с указанным именем"
-    Писать:
-      тип: прц
-      парам:
-        - ФайлИмя имя
-        - Ос.Права права
-      вых:
-      - ОптОш +изм
-      док: "Записывает файл с указанным именем и правами"
+```python
+спец(
+  имя(ИФайл)
+  прц(
+    имя(Читать)
+    парам(
+      ФайлИмя(нов имя)
+    )
+    вых(
+      РезБайты(нов рез)
+    )
+    док("Читает файл с указанным именем")
+  )
+  прц(
+    имя(писать)
+    парам(
+      ФайлИмя(нов имя)
+      Ос(.Права)(нов права)
+    )
+    вых(
+      ОптОш(нов рез +изм)
+    )
+    док("Записывает файл с указанным именем и правами")
+  )
+)
+
 ```
 
 Все конструкции — одного синтаксического вида, но семантика управляется *контекстом в начале*:
@@ -131,30 +165,34 @@
 
 Доступны только:
 
-* прц: ...,
-* фн: ...,
-* протон: ...,
-* протон: ...,
-* словарь: ...,
-* список: ...,
-* если ...,
-* цикл ...
+* `прц(...)`
+* `фн(...)`
+* `протон(...)`
+* `протон(...)`
+* `словарь(...)`
+* `список(...)`
+* `если(...)`
+* `цикл(...)`
 
 Нет доступа к:
 
-* `система` (эффект, низкоуровневый),
-* `кварк` (эффект, низкоуровневый),
-* `макро` (эффект, низкоуровневый, манипуляция AST).
-
-```yml
-прц:
-  имя: Приветствовать
-  эффект:
-    - терм_вых
-  парам:
-    - ГостьИмя имя
-  нач:
-    - Печатать "Привет, " имя "!"
+* `система()` (эффект, низкоуровневый),
+* `кварк()` (эффект, низкоуровневый),
+* `макро()` (эффект, низкоуровневый, манипуляция AST).
+
+```python
+прц(
+  имя(Приветствовать)
+  эффект(
+    терм_вых()
+  )
+  парам(
+    ГостьИмя(нов имя)
+  );
+  нач(
+    Печатать("Привет, {имя}!")
+  )
+)
 ```
 
 Простота **Лиспа**, но в безопасной оболочке диалектического языка.
@@ -163,15 +201,19 @@
 
 Открываются:
 
-* атом: ...,
-* спец: ...,
+* `атом(...)`
+* `спец(...)`
 
 ```yml
-атом:
-  имя: Точка
-  протон:
-    - ПозX х
-    - ПозУ у
+атом(
+  имя(Точка)
+  протон(
+    имя(ПозХ)
+  )
+  протон(
+    имя(ПозУ)
+  )
+)
 ```
 
 Язык начинает развиваться, но в рамках контролируемой системы.
@@ -186,35 +228,55 @@
 * `адр` (работа на уровне ВМ)
 * макро: ... (манипуляция AST)
 
-```yml
-макрос:
-  имя: когда
-  парам:
-    - тело условие
-    - тело кодДа
-    - тело кодНет
-  эффект:
-    - квалификация специалист
-    - тест
-  док: "Удобный макрос-обёртка над если"
-  нач:
-    - если условие
-    - _ тогда {кодДа}
-    - _ иначе {кодНет}
-
-прц:
-  имя: КопироватьПамять
-  эффект:
-    - система
-    - кварк
-    - квалификация специалист
-    - тест
-  парам:
-    - СисАдр цель источник +изм
-    - СисКолич длина
-  нач:
-    - Сохр рег3 длина
-    - Цикл рег0 до рег2 ЦельПеремещ рег0
+```python
+макрос(
+  имя(когда)
+  парам(
+    тело(нов условие)
+    тело(нов кодДа)
+    тело(нов кодНет)
+  )
+  эффект(
+    квалификация(специалист)
+    тест()
+  )
+  док("Удобный макрос-обёртка над если")
+  нач(
+    если(условие
+      тогда(
+        тело(встав кодДа)
+        ..()
+      )
+    )
+    тело(встав кодНет)
+  )
+)
+
+
+прц(
+  имя(КопироватьПамять)
+  эффект(
+    система()
+    кварк()
+    квалификация(специалист)
+    тест()
+  )
+  парам(
+    СисАдр(нов цель)
+    СисАдр(нов источник +изм)
+    СисКолич(нов длина)
+  )
+  нач(
+    Сохр(рег3 длина)
+    Цикл(
+      ЦельПеремещ(рег0)
+      СисАдр(инк источник)
+      СисАдр(срав источник длина)
+      ЦиклСтоп(рез)
+      СисАдр(инк цель)
+    )
+  )
+)
 ```
 
 **Но!** Такой код не компилируется без:
@@ -225,31 +287,51 @@
 
 ## Семантическая экономия: один синтаксис — разный смысл по контексту
 
-```yml
-спис: Цел 1 2 3
-атом:
-  имя: Пользователь
-  протон:
-    - ЧелИмя     имя
-    - ЧелВозраст возраст +изм
-    - Роль       роль    +изм
-спец:
-  имя: Проверятор
-прц:
-  имя: Пуск
-  нач:
-    - ПользовательНов
-    - _  имя     "Анна"
-    - _  возраст 28
-    - _  роль    Админ
-    - уст ...
-фн:
-  имя: ФайлПроверить
-  парам:
-    - СписБайт нечто
-  нач:
-    - нечто .длина > 0
-    - если рез Файл записать нечто
+```python
+СписЦел(нов 1 2 3)
+атом(
+  имя(Пользователь)
+  протон(
+    имя(ЧелИмя)
+    тип(Стр)
+  )
+  протон(
+    имя(ЧелВозраст +изм)
+    тип(Цел)
+  )
+  протон(
+    имя(Роль +изм)
+    тип(Стр)
+  )
+)
+
+спец(
+  имя(Проверятор)
+  прц(
+    имя(Пуск)
+    нач(
+      Пользователь(нов
+        имя("Анна")
+        возраст(28)
+        роль(Админ)
+        уст(<...>)
+      )
+    )
+  )
+  фн(
+    имя(ФайлПроверить)
+    парам(
+      СписБайт(нов нечто)
+    )
+    нач(
+      СписБайт(срав нечто(.длина) > 0)
+      если (рез
+        тогда (
+          Файл(записать нечто)
+        )
+      )
+  )
+)
 ```
 
 Это — диалектическая гибкость: форма одна, но смысл возникает в практике применения, а не в синтаксической избыточности.
@@ -258,19 +340,28 @@
 
 Макросы — не анархия, а организованное развитие.
 
-```yml
-макрос:
-  имя: конкурент
-  парам:
-    - тело код
-  нач:
-  - поток {код}
-  - док: "Запускает конкурентно тело выражения"
-
-прц:
-  имя: Пуск
-  нач:
-    - конкурент ЗагрузитьДанные ОбновитьИнтерфейс
+```python
+макрос(
+  имя(конкурент)
+  парам(
+    тело(нов код)
+  )
+  нач(
+    тело(встав код)
+    док("Запускает конкурентно тело выражения")
+  )
+)
+
+
+прц(
+  имя(Пуск)
+  нач(
+    конкурент(
+      ЗагрузитьДанные()
+      ОбновитьИнтерфейс()
+    )
+  )
+)
 ```
 
 Но:
@@ -285,20 +376,26 @@
 
 Переход на низкий уровень — не синтаксическое волшебство, а сознательный акт:
 
-```yml
-фн:
-  имя: СложитьАдреса
-  эффект:
-    - система
-    - обоснование "оптимизация критического участка"
-    - ревью
-    - квалификация специалист
-  парам:
-    - СисАдр a b
-  нач:
-    - РодИзвлечь a
-    - РодИзвлечь b
-    - Яблоко сложить a b
+```python
+фн(
+  имя(СложитьАдреса)
+  эффект(
+    система()
+    обоснование("оптимизация критического участка")
+    ревью()
+    квалификация(специалист)
+  )
+
+  парам(
+    СисАдр(нов a)
+    СисАдр(нов b)
+  )
+  нач(
+    РодИзвлечь(a)
+    РодИзвлечь(b)
+    Яблоко(слож a b)
+  )
+)
 ```
 
 Что даёт такая форма:

docs/docs/01_70.md

@@ -43,18 +43,32 @@
 
 ```yml
 # Если не указан атрибут изменяемости -- по умолчанию фикс
-фн:
-  имя: Cложить
-  парам:
-    - Час a b
-  нач:
-    - Час сложить a b
+фн(
+  имя(Cложить)
+  парам(
+    Час(нов a)
+    Час(нов b)
+  )
+  нач(
+    Час(слож a b)
+  )
+)
+
+
+атом(
+  имя(Пользователь)
+  протон(
+    имя(ЧеловекИмя)
+    тип(Стр)
+    домен(1 100)
+  )
+  протон(
+    имя(ЧеловекВозраст)
+    тип(Цел)
+    домен(0 120)
+  )
+)
 
-атом:
-  имя: Пользователь
-  протон:
-    - ЧеловекИмя имя
-    - ЧеловекВозраст возраст
 
 прц:
   имя: Пуск