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

.gitignore

@@ -30,3 +30,8 @@ docs/draft.md
 docs/!draft.md
 **/__pycache__
 .continue
+
+
+# Added by cargo
+
+/target

Taskfile.yml

@@ -18,6 +18,14 @@ tasks:
       - go run -race ./cmd/proi/main.go
     env:
       MAIN_PROLET: ./plt/main.plt
+  mod:
+    desc: "Установка/обновление всех зависимостей модулей"
+    cmds:
+      - go get -u ./...
+      - go mod tidy -compat=1.25.6
+      - go mod vendor
+      - go mod verify
+      - go fmt ./...
   ollama:
     desc: "Запуск LLM под мою конфигурацию железа"
     cmds:
@@ -26,3 +34,19 @@ tasks:
      OMP_NUM_THREADS: 16
      OMP_PROC_BIND: true
      OMP_PLACES: cores
+  read:
+    desc: "Чтение файла (pdftotext read.pdf > read.txt)"
+    cmds:
+      - RHVoice-client -s Anna+CLB < read.txt | aplay
+  wav:
+    desc: "Создание wav файла"
+    cmds:
+      - cat read.txt | RHVoice-client -s Anna+CLB > read.wav
+  pros:
+    desc: "Запуск сервера prolet на brython"
+    cmds:
+      - clear
+      - cp -aT ./pub ./bin/pub
+      - go fmt ./...
+      - go build -race -o ./bin/pros ./cmd/pros/main.go
+      - cd ./bin && ./pros

cmd/pros/main.go

@@ -0,0 +1,16 @@
+// package main -- пускач для сервера prolet с brython
+package main
+
+import (
+	"log"
+
+	"github.com/gofiber/fiber/v3"
+	"github.com/gofiber/fiber/v3/middleware/static"
+)
+
+func main() {
+	log.Println("prolet on brython")
+	app := fiber.New()
+	app.Use("/", static.New("./pub"))
+	_ = app.Listen(":18080")
+}

docs/docs/00_10.md

@@ -99,7 +99,7 @@
 Каждый новый язык отрицает недостатки предыдущего:
 
 - `C`: небезопасное управление памятью → `Python` добавляет **ООП**, динамическую типизацию, но усложняет контроль.
-- `Python`: медленный, динамический → `Go` предлагает кратно больше безопасности и скорости, но с **GC**.
+- `Python`: медленный, динамический → `Go` предлагает кратно больше скорости как в `C`, но кратно безопасности с **GC**.
 
 ### Этап 2: Отрицание отрицания (синтез на новом уровне)
 
@@ -118,7 +118,7 @@
 
 Постепенное накопление улучшений:
 
-- Небольшие расширения синтаксиса (теги-действия, сопоставление с образцом),
+- Небольшие расширения синтаксиса (эффекты, сопоставление с образцом),
 - Улучшения системы типов,
 - Инструменты (форматеры, линтеры),
 - Экосистема библиотек.
@@ -153,7 +153,7 @@
 - `Scala` — мощный, но сложный → ограниченное распространение.
 - `Go` — простой, но эффективный → массовое внедрение в облаках.
 
-Практика показывает, что работает.
+Практика как критерий истины показывает, что на самом деле работает.
 
 ## Роль сознания (программисты, как носители труда)
 

docs/docs/00_20.md

@@ -21,7 +21,7 @@
 
 Пример:
 
-- `@изм` (изменяемость) ↔ `@фикс` (неизменность)
+- `+изм` (изменяемость) ↔ отсутствие атрибута (неизменность)
 - `Процесс` (практика) ↔ `Функция` (закон)
 
 → их единство и борьба и рождает новый уровень — `протон` и `нейтрон` (конкретный тип), `атом`(конкретная структура).
@@ -42,7 +42,7 @@
 
 - Тезис: "всё — типы" (идеализм)
 - Антитезис: "нет типов, только сущее" (материализм)
-- Синтез: "типы существуют как проекции сущего" — диалектика.
+- Синтез: "типы существуют как обобщение сущего" — диалектика.
 
 ### Объективность
 
@@ -80,11 +80,11 @@
 
 Он говорит:
 
-> «Ну и что, что `@изм` внутри `@фикс`? Пусть будет — удобно».
+> «Ну и что, что `+изм` и `+фикс` существуют одновременно? Пусть будет — удобно».
 
 ### Субъективизм
 
-> Критерий истины — не практика, а *личное предпочтение*, *мода*, *авторитет*.
+> Критерием истины становится не практика, а *личное предпочтение*, *мода*, *авторитет*.
 
 ### Статичность
 
@@ -110,14 +110,14 @@
 
 Одно из принятых правил для реализации в языке программирования **prolet**:
 
-> `В prolet не будет абстрактных типов вроде int, string. Будут только типы сущего.`
+> `В prolet не будет абстрактных типов вроде int, string. Будут только обощения сущего.`
 
 Это правило на основе применения диалектики:
 
 > Это разрешение противоречия между идеализмом типов и материализмом практики,
 > и разрешает его через синтез:
 >
-> «Тип — проекция сущего, зафиксированная в практике».
+> «Обощение — проекция сущего, зафиксированная в практике».
 
 Если бы правило было:
 

docs/docs/01_10.md

@@ -34,5 +34,5 @@
 - Материя (аппарат, задачи, опыт) → первична.
 - Противоречия → двигатель.
 - Практика → критерий истины.
-- Сознание (разработчики) → руководит процессом (направляет его), но не создаёт законы.
+- Сознание (разработчики) → руководит процессом (направляет его), но подчиняется физическим законам.
 - Время необратимо.

docs/docs/01_20.md

@@ -64,7 +64,7 @@
 - Он определяет скорость и качество создания программ;
 - Он влияет на распределение ресурсов (энергия, память, время).
 
-Следовательно, разработка языка — с одной стороны акт индивидуального творчества, с другой стороны -- акт коллективной значимости.
+Следовательно, разработка языка — с одной стороны акт индивидуального творчества, с другой стороны -- акт коллективного влияния.
 
 Капиталистический подход: язык, который делает программиста зависимым от проприетарных платформ (`Swift`, `C#` в прошлом).
 
@@ -103,7 +103,7 @@
 
 ### Принцип противоречия
 
-Язык должен не избегать противоречий, а позволять их осознанно разрешать (например, безопасность vs производительность — через явные аннотации).
+Язык должен не избегать противоречий, а позволять их осознанно разрешать (например, безопасность vs производительность — через явные эффекты).
 
 ### Принцип историчности
 
@@ -140,7 +140,7 @@
 
 > `"Типы существуют в идеальном мире"`
 
-Типы — инструмент для предотвращения ошибок в реальных системах.
+Обощения — результат практики, инструмент по отношению к человеку, но субъект по отношению к обобщаемым данным для предотвращения ошибок в реальных системах.
 
 ### Культ элегантности
 

docs/docs/01_30.md

@@ -24,38 +24,42 @@
 
 Диалектическое разрешение:
 
-> `Иерархия уровней абстракций с прозрачным контролем при переходе между уровнями.`
+> `Иерархия уровней обощения с прозрачным контролем при переходе между уровнями.`
 
-Язык предоставляет высокоуровневые конструкции по умолчанию (например, `List`, `Stream`, `Actor`).
-Но позволяет спускаться к низкоуровневому коду, если это требует практика.
-Переход между уровнями не скрыт, а явен — через ключевое слово низкоуровневый или аннотацию `@система`.
+Язык предоставляет высокоуровневые контексты по умолчанию (например, `Целое`, `Изолят`, `..`). Но позволяет спускаться к низкоуровневому коду, если это требует практика.
+Переход между уровнями не скрыт, а явен — через эффекты `низкоуровневый` или `система`.
 
 Пример:
 
-```prolet
-(прц ОбработатьДанные (СписокБайт данные @изм) СписокБайт (
-    (// высокоуровневая композиция)
-    (ФильтроватьДанные х по данные
-            (Сравнить х > 10)
-            (ФнКвадрат рез))
-    )
-    (вернуть рез)
-)
+```yml
+прц:
+  имя: ОбработатьДанные
+  парам:
+      - СписокБайт данные +изм
+  # высокоуровневая композиция
+  нач:
+    - ФильтроватьДанные данные
+    - Сравнить рез > 10
+    - ФнКвадрат
+    - .. рез
 ```
 
-```prolet
-(// при необходимости — ручное управление)
-(прц КопироватьПамять @система (
-       (СисАдр источник    СисАдр цель    СисРазмер размер)
-    (
-        асм (ПовторОтДо источник цель)
-    )
-)
+```yml
+# при необходимости — ручное управление
+прц:
+    имя: КопироватьПамять
+    эффект:
+        - система
+    парам:
+        - СисАдр источник +изм цель +изм
+        - СисРазмер размер
+    асм:
+        - ПовторОтДо источник цель
 ```
 
 Философский смысл:
 
-> `Единство абстрактного и конкретного`
+> `Единство обощённого и конкретного`
 
 Сознание не отрывается от материи — программист видит, что происходит с памятью.
 
@@ -65,7 +69,7 @@
 
 Антиподы:
 
-- Безопасность требует ограничений (проверка типов, владение, immutability).
+- Безопасность требует ограничений (проверка типов, владение, неизменяемости).
 - Гибкость требует свободы (указатели, рефлексия, изменение поведения в рантайме).
 
 Идеалистический путь:
@@ -78,13 +82,13 @@
 
 Диалектическое разрешение:
 
-> `Безопасность по умолчанию, гибкость по необходимости, с явным указанием ответственности программиста.`
+> `Безопасность по умолчанию; гибкость по необходимости, но с явным указанием ответственности программиста.`
 
 По умолчанию:
 
 - Вся память управляется системой существования (как в линейных или афинных типах, но с ориентацией на законы реального мира),
 - Все данные — неизменяемые,
-- Побочные эффекты — явно следуют из кода.
+- Эффекты — явно следуют из декларации в коде.
 
 При необходимости — выход из рамок, но:
 
@@ -92,22 +96,32 @@
 - С явным комментарием причины (автоматически включается в документацию),
 - С обязательным тестированием.
 
-```prolet
-(// Функции никогда ничего не изменяют )
-(фн СложитьДист1 (Км a   М b) Км (
-    (СложитьКмМ a b)
-    (вернуть рез)
-  )
-)
-
-( // Процессы могут, но не обязаны иметь побочные эффекты)
-(прц ЗначПоАдр @система
-        @обоснование "взаимодействие с драйвером"
-        (Адр адр @изм) Адр (
-      (ЗначИз адр)
-      (вернуть рез)
-    )
-)
+```yml
+# Функции никогда ничего не изменяют
+фн:
+  имя: СложитьДист1
+  парам:
+    - Км a
+    - М b
+  вых:
+    - Км рез
+  нач:
+    - СложитьКмМ a b
+    - .. рез
+
+# Процессы могут, но не обязаны иметь побочные эффекты
+прц:
+  имя: ЗначПоАдр
+  эффект:
+    - система
+    - драйвер "взаимодействие с менджером памяти"
+    парам:
+      Адр: адр +изм
+    вых:
+      - Адр рез
+    нач:
+      - ЗначИз адр
+      - .. рез
 ```
 
 Философский смысл:
@@ -138,7 +152,7 @@
 
 - Минимальный синтаксис,
 - Интерактивная среда,
-- Интегрированная помощь (как **REPL** с подсказками от "Центра обучения").
+- Интегрированная помощь (встроенный в  **REPL** "Центра обучения").
 
 По мере роста:
 
@@ -178,35 +192,56 @@
 
 Диалектическое разрешение:
 
-> `Гибридная система с постепенной типизацией и выводом.`
+> `Гибридная система со спецификациями и контекстами-типами.`
 
-Все переменные имеют тип, и он может быть выведен при назначении имени значению.
+Все переменные имеют контесты-типы, и контекст-тип может быть выведен при назначении имени значению и при использовании значения.
 
-Можно использовать динамический тип, но:
+Можно использовать динамический контекст-тип, но:
 
 - Только в ограниченных зонах,
 - С предупреждением, (если не подавлено)
-- *Не разрешён* в критических модулях (ядро, безопасность).
+- *Не разрешён* в критических модулях (ядро, безопасность; при указании соответствующих эффектов).
 
-Система типов расширяема: Пользователь может определять зависимые типы для критически важных участков.
+Система контекстов расширяема: пользователь может определять зависимые контексты для критически важных участков.
 
 Пример:
 
-```prolet
-(// тип выведен: Целое;
-    определение @фикс -- если не указано устанавливается по умолчанию)
-(Рубль 42)(уст х)
-
-(// явная динамика — только при необходимости,
-    тип нечто -- определяется на стороне вызова)
-(ПолучитьИзВнешнегоАпи)(уст нечто)
-
-(// но в блоке безопасности — только статика)
-(фн ПроверитьДоступ @строго(
-        Пользователь пользователь
-        Роль         роль) ЕслиОк (
-    (// динамические типы запрещены здесь))
-)
+```yml
+# тип выведен: Целое
+#    эффект +изм — если не указано то неизменяемо
+прц:
+  имя: Пуск
+  нач:
+    - Рубль нов 42
+    - уст х
+
+# явная динамика — только при необходимости
+#    тип нечто — определяется как СрезБайт
+прц:
+  имя: Пуск
+  эффект:
+    - нечто
+  нач:
+   - ПолучитьИзВнешнегоАпи
+   - уст нечто
+
+# но в блоке безопасности — только статика
+фн:
+  имя: ПроверитьДоступ
+  эффект:
+    - нечто
+  парам:
+    - Пользователь пользователь +изм
+    - Роль         роль +изм
+  вых:
+    - Пользователь рез
+  нач:
+   - ЕслиНечто нечто
+   - Пользователь изБайт нечто
+   # динамические типы запрещены здесь
+   - если рез .еслиОш
+   - _ тогда Паника "ПроверитьДоступ: кривые данные для пользователя"
+   - .. рез .знач
 ```
 
 Философский смысл:
@@ -220,15 +255,15 @@
 Антиподы:
 
 - Индивидуализм — "я написал, я понимаю".
-- Коллективизм — код как достояние коллектива.
+- Коллективизм — код, как достояние коллектива.
 
 Диалектическое разрешение:
 
 `Язык встроен в экосистему коллективного труда.`
 
-Встроенные механизмы:
+Встроенные механизмы эффектов:
 
-- `@автор`, `@соавторы`, `@история_изменений`,
+- `автор`, `соавторы`, `история_изменений`,
 - Обязательные рецензии перед коммитом (на уровне языка),
 - Автоматическая генерация отчётов о вкладе (для оценки труда).
 - Код-ревью — не опционально, а обязательная фаза компиляции в производство.
@@ -238,7 +273,7 @@
 - Индивидуальное творчество служит коллективу.
 - Нет места "гению в подвале", есть место участнику команды трудящихся умственного труда.
 
-> 💡 Программирование -- практическая форма *общественных* отношений.
+> 💡 Программирование — практическая форма *общественных* отношений.
 
 ### Общее разрешение: язык как диалектический синтез
 
@@ -256,6 +291,8 @@
 - Постепенная типизация с контекстом
 - Индивидуализм vs Коллективизм
 - "Я" vs "Мы"
+- Длинные строки vs короткие
+- Высокая вложенность vs композиция
 
 `Код — достояние коллектива, труд — прозрачен`
 

docs/docs/01_40.md

@@ -12,20 +12,20 @@
 
 Суть противоречия:
 
-- Высокий уровень — близок к человеческому мышлению, безопасен, продуктивен.
-- Низкий уровень — близок к машине, эффективен, но опасен, требует глубоких знаний.
+* Высокий уровень — близок к человеческому мышлению, безопасен, продуктивен.
+* Низкий уровень — близок к машине, эффективен, но опасен, требует глубоких знаний.
 
 Риск:
 
-- Если не ограничить доступ — новичок сломает систему.
-- Если запретить — эксперт будет сдерживаться.
+* Если не ограничить доступ — новичок сломает систему.
+* Если запретить — эксперт будет сдерживаться.
 
 Задача: создать диалектическую границу, которая:
 
-- Не исчезает (не идеализм),
-- Не непреодолима (не метафизика),
-- Поддерживает развитие (диалектика),
-- Учитывает психологию программиста (гуманизм).
+* Не исчезает (не идеализм),
+* Не непреодолима (не метафизика),
+* Поддерживает развитие (диалектика),
+* Учитывает психологию программиста (гуманизм, инженерная психология).
 
 ## 📙 Принципы проектирования синтаксиса (на стыке философии и психологии)
 
@@ -35,7 +35,7 @@
 
 ### Принцип когнитивной видимости
 
-Низкоуровневые участки визуально и семантически выделены, чтобы мозг сразу распознавал повышение риска.
+Низкоуровневые участки как визуально, так и семантически выделены, чтобы мозг сразу распознавал повышение риска.
 
 ### Принцип постепенного погружения
 
@@ -53,144 +53,206 @@
 
 Вариант 1: Явный блок низкоуровневый с контекстным предупреждением
 
-```prolet
-(прц ОбработатьДанные (Список.Байт вход @изм) Список.Байт (
-    (// Высокий уровень — чисто, безопасно)
-    (ФильтрПо вход
-        (x > 10)
-        ( @рез * 2))
-    )
-)
-
-(// Внимание! Здесь действуют другие законы)
-(прц СкопироватьПамять @система
-        @прог_уровень 3
-        @одобрение_нужно
-        (Байт     источник
-         Байт     цель
-         СбщДлина длина)(
-    (Цикл для i от 0 до длина
-        (// Прямое обращение к памяти)
-        (кварк (Цел загр i статус))
-    )
-)
+```yml
+прц:
+  имя: ОбработатьДанные
+  парам:
+    - СписокБайт вход +изм
+  вых:
+    - СписокБайт
+  нач:
+    # Высокий уровень — чисто, безопасно)
+    - ФильтрПо вход > 10
+    - СписокБайт * рез 2
+    - .. рез
+
+# Внимание! Здесь действуют другие законы
+прц:
+  имя: СкопироватьПамять
+  эффект:
+    - система
+    - квалификация 3
+    - одобрение нужно
+  парам:
+    - Байт источник цель
+    - СбщДлина длина
+    нач:
+      # Прямое обращение к памяти в цикле
+      - Цикл от 0 до длина
+      - _ ПрцКварк рез
 ```
 
 Психологические преимущества:
 
-- Свойство `@система` — семантический маркер, активирует режим повышенного внимания.
-- Цвет подсветки — красный или оранжевый (по стандартам **UX**).
-- **IDE** показывает подсказку: "Вы вошли в зону повышенного риска. Проверьте указатели, границы массивов."
+* Эффект `система` — семантический маркер, активирует режим повышенного внимания.
+* Цвет подсветки — красный или оранжевый (по стандартам **UX**).
+* **IDE** показывает подсказку: "Вы вошли в зону повышенного риска. Проверьте указатели, границы массивов."
 
 Диалектический смысл:
 
-- Граница не устранена, но преодолима сознательно.
-- Противоречие разрешено через форму, а не подавление.
-- Компилятор требует внешней проверки (главный человек, а не система).
+* Граница не устранена, но преодолима сознательно.
+* Противоречие разрешено через форму, а не подавление.
+* Компилятор требует внешней проверки (главный человек, а не система).
 
 Вариант 2: Модульный подход с уровнем доступа
 
-```prolet
-(модуль БезопаснаяОбработка (
-    (прц Фильтровать(ДанныеПоток данные @изм ) ДанныеПоток (
-        если (Сравнить данные @длина > 10)
-        тогда (ДобСписок данные))
-    )
-)
-
-(// Только для программистов с уровнем >= 3, старший инженер)
-(модуль НизкоуровневаяОптимизация
-    @мод_уровень 4
-    (импорт
-        Ядро.Память
-        Ядро.Асм)
-
-    (фнКопироватьБыстро @система (...) (...))
-)
+```yml
+модуль:
+  имя: БезопаснаяОбработка
+  прц:
+    имя: Фильтровать
+    парам:
+      - ДанныеПоток данные +изм
+    вых:
+      - ДанныеПоток
+    нач:
+        - Сравнить данные .длина > 10
+        - если рез
+        - _ тогда ДобСписок данные
+        - .. рез
+
+# Только для программистов с уровнем > 3, специалист
+модуль:
+  имя: НизкоуровневаяОптимизация
+  эффект:
+    - компетенция 4
+  импорт:
+        - Ядро.Память
+        - Ядро.Асм
+  фн:
+    имя: фнКопироватьБыстро
+    эффект:
+      система
+    нач:
+      -...
+      -...
 ```
 
-Реализация "готовности":
+### Градации программистов
 
-- У программиста есть уровень компетенции (1..5) для реализации и проверки
-- Уровень определяется пройденными учебными модулями (1..3) и опытом (4, 5),
+| Сила/Опыт | Уровень | Коментарий |
+| ---   | ---       | --- |
+| 0..2  |ученик     |учится программировать, не знает языка |
+| 3..8  |студент    |знает язык, идиомы, не знает окружения |
+| 9..15 |специалист |знает рабочее окружение |
+| 16..29|эксперт    |широкое системное видение |
+| 30..  |мастер     |знает всё, обширный опыт |
 
-Компилятор блокирует импорт модулей уровня (1..3), если:
+> Баллы = сила + опыт
 
-- у разработчика уровень < 3.
-- у модуля недостаточный уровень
+При наличии глубоких знаний или обширного опыта -- грейд повышается.
 
-Можно запросить временный доступ с одобрения старшего программиста.
+В норме:
+
+* сила -- 50%;
+* опыт -- 50%.
+
+При установке компилятора -- программа установки спрашивает данные програмиста и его грейд. Для подтверждения грейда запускает тест соответствующего уровня.
+
+## Реализация "готовности"
+
+* У программиста есть уровень компетенции (ученик..мастер) для реализации и проверки
+* Уровень определяется пройденными учебными модулями (1..3) и опытом (4, 5),
+
+Компилятор блокирует разработку модулей с эффектом "система", если:
+
+* у разработчика уровень меньше эксперт;
+* у модуля есть импорт с эффектами, которые не знает программист.
+
+Можно запросить временный доступ под ответственность старшего программиста и обязательные тесты.
 
 Психологический эффект:
 
-- Создаёт систему постепенного вхождения, как в боевую подготовку.
-- Формирует ответственность, а не безрассудную смелость.
-- Повышает контроль за опасными средствами.
+* Создаёт систему постепенного вхождения, как в боевую подготовку.
+* Формирует ответственность, а не безрассудную смелость.
+* Повышает контроль за опасными средствами.
 
-При этом снимает ответственность с программиста, если его уровень для выполнения соответствующей задачи недостаточен.
+При этом защищает программиста от отсутствующих обязанностей, если его уровень для выполнения соответствующей задачи недостаточен.
 
 Вариант 3: Гибридный синтаксис с "прозрачным спуском"
 
-```prolet
-(прц ОбработатьГруппу @уровень_ниже(
-    (ПолучитьДанные) данные(
-    (// Высокий уровень)
-    (ГруппироватьПо данные @ключ)(уст группа)
-    (СуммироватьПо данные группа)(уст результат)
-
-    (// Спуск в низкий уровень — через ключевое слово и атрибут)
-        (// Теперь можно использовать указатели, asm)
-        (кварк
-            (Цел копия рез х1)
-            (инк рез))
-    )
-
-    (// Подъём автоматически))
-    вернуть рез
-)
+```yml
+прц:
+  имя: ЦелКопияИнк
+  эффект:
+    - кварк
+  парам:
+    - Целое вх
+  вых:
+    - Целое
+  нач:
+    - Цел копия вх х1
+    - Цел инк рез
+    - .. рез
+
+прц:
+  имя: ОбработатьГруппу
+  эффект:
+    - уровень_ниже
+  парам:
+    - ПолучитьДанные данные
+  нач:
+    # Высокий уровень
+    - ГруппироватьПо данные .ключ
+    - уст группа
+    - СуммироватьПо данные .группа
+    # Спуск в низкий уровень — через вызов функции/процесса в которых указананы эффекты
+    # Теперь можно использовать указатели, asm)
+    - ЦелКопияИнк рез
+    # Подъём автоматически
+    - .. рез
 ```
 
 Особенности:
 
-Атрибут `@уровень_ниже` — синтаксический шлюз, как шлюз в подводной лодке.
+Эффект `уровень_ниже` — синтаксический шлюз, как шлюз в подводной лодке.
 
-- При входе — предупреждение в **IDE**, подсветка фона.
-- Автоматический возврат к безопасному контексту после выхода.
+* При входе — предупреждение в **IDE**, подсветка фона.
+* Автоматический возврат к безопасному контексту после выхода.
 
 Когнитивная выгода:
 
-- Мозг четко фиксирует границу.
-- Не нужно держать в памяти: "а я всё ещё в `@система`?".
-- Уменьшает когнитивную нагрузку.
-- На уровне компилятора перехватывает обращение к опасным средствам.
+* Мозг четко фиксирует границу.
+* Не нужно держать в памяти: "а я всё ещё в эффекте `система`?".
+* Уменьшает когнитивную нагрузку.
+* На уровне компилятора перехватывает обращение к опасным средствам.
 
 Вариант 4: Интеграция с системой обучения (обучающий компилятор)
 
-```prolet
-(прц ОбработатьПамять @система (Срез.Байт размер)) АсмИмя(
-    (// Компилятор замечает:  "Вы используете сырые указатели")
-    если (Сравнить уровень < 3)
-    тогда (ПройтиМодуль "Управление памятью (5 мин)")
-    иначе (ИспользоватьБезопасныйАналог "БуферБайт")
-    )
-    вернуть рез
-)
+```yml
+прц:
+  имя: ОбработатьПамять
+  эффект:
+    - система
+  парам:
+    - Срез.Байт размер
+  вых:
+    - АсмИмя
+    # Компилятор замечает:  "Вы используете сырые указатели"
+  нач:
+    - Компилятор сравнить уровень < 3
+    - Компилятор если рез
+    - _ тогда ПройтиМодуль "Управление памятью (5 мин)"
+    - _ иначе ИспользоватьБезопасныйАналог "БуферБайт"
+    - .. рез
 ```
 
 Реализация:
 
-1. Встроенный обучающий агент анализирует код.
-2. При обнаружении низкоуровневых конструкций:
+* Встроенный обучающий агент анализирует код,
+* Статическая проверка кода на этапе компиляции.
+
+При обнаружении низкоуровневых конструкций:
 
-- Показывает подсказку,
-- Предлагает обучающий модуль,
-- Может заблокировать коммит, пока модуль не пройден.
+* Показывает подсказку,
+* Предлагает обучающий модуль,
+* Может заблокировать коммит, пока модуль не пройден.
 
 Философский смысл:
 
-- Единство обучения и труда.
-- Программист не просто пишет код — он развивается в процессе.
-- Это — диалектическая школа программирования, отвечающая запросам сообщества.
+* Единство обучения и труда.
+* Программист не просто пишет код — он развивается в процессе.
+* Это — диалектическая школа программирования, отвечающая запросам сообщества.
 
 Рекомендованная модель: синтез вариантов (диалектический выбор)
 
@@ -198,24 +260,24 @@
 
 Поддержка **IDE**:
 
-- Цветовая зона: зелёная → жёлтая → красная.
-- При наведении: "Вы находитесь в зоне высокой ответственности. Рекомендуется ревью."
-- Автоматическое предложение: "Заменить на безопасный аналог?"
+* Цветовая зона: зелёная → жёлтая → красная.
+* При наведении: "Вы находитесь в зоне высокой ответственности. Рекомендуется ревью."
+* Автоматическое предложение: "Заменить на безопасный аналог?"
 
 ## 🎯 Заключение
 
 Язык программирования может быть спроектирован:
 
-- как многоуровневый по возможностям;
-- как педагогический механизм;
-- как дополнительное средство безопасности, встроенное в сам язык.
+* как многоуровневый по возможностям;
+* как педагогический механизм;
+* как дополнительное средство безопасности, встроенное в сам язык.
 
 Синтаксис языка — это не абстрактная форма, а содержание практического, деятельного сознания.
 
 Реализация противоречия "низкий/высокий уровень" должна:
 
-- Не устранять границу (иначе — анархия),
-- Не делать её вечной (иначе — бюрократия),
-- Превращать её в лестницу развития.
+* Не устранять границу (иначе — анархия),
+* Не делать её вечной (иначе — остановка развития),
+* Превращать её в лестницу развития.
 
 > ✅ `prolet` не просто средство написания программ, а средство воспитания программиста нового типа — диалектического, ответственного, коллективистского, готового к труду и обороне в цифровую эпоху.

docs/docs/01_50.md

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

docs/docs/01_55.md

@@ -1,10 +1,10 @@
 # pro.01_55 Диалектика формы языка программирования
 
-В качестве базовой реализации языка программирования **prolet** принята форма заключение всех сущностей в круглые скобки. На первом месте стоит контекст, имеющий смысл "в заданных границах исполни действие в скобках". Единственная форма, не имеющая контекста -- пара круглых скобок: контекст отменяющий результат (см. далее).
+В качестве базовой реализации языка программирования **prolet** принята форма заключение всех сущностей в `YAML`. На первом месте стоит контекст, имеющий смысл "в заданных границах исполни действие в блоке". Единственная форма, не имеющая контекста -- одиночная точка: контекст отменяющий результат (см. далее).
 
 Синтаксис закрепляет онтологический принцип в форме языка.
 
-> 💡 «Исполни контекст в скобках» — это не инструкция, это — утверждение о природе конкретного вычисления как материи в движении.
+> 💡 «Исполни контекст в блоке — это не инструкция, это — утверждение о природе конкретного вычисления как материи в движении.
 
 Разберём решение в свете диалектического материализма, и закрепим его как фундаментальную аксиому языка **prolet**.
 
@@ -15,9 +15,15 @@
 > Только процесс может породить результат.
 > Нет "значения без действия", нет "сущего без движения".
 
-Форма `(%контекст %возможно_действие %возможно_аргументы...)` — выражает единство формы и содержания:
+Форма:
 
-- Круглые скобки — граница процесса, как диафрагма в лёгких в разных положениях, разделяющая состояние на вдох и выдох.
+```text
+<контекст>  <возможно_действие>  <возможно_аргументы>
+```
+
+выражает единство формы и содержания:
+
+- начало и конец строки — граница процесса, как диафрагма в лёгких в разных положениях, разделяющая состояние на вдох и выдох.
 - Первый элемент *контекст* — ограничитель и цель процесса, смысловая нагрузка всей формы, вектор направления, обязателен кроме описанного случая выше.
 - Второй элемент "возможно_действие" -- действие, допустимое в текущем контексте, необязательный параметр;
 - Остальное — аргументы — необязательные материалы, подвергаемые преобразованию.
@@ -28,69 +34,77 @@
 
 Контекст — не синтаксическое украшение, он — руководящее начало, идеологический центр процесса.
 
-- `(фн ...)` -- контекст организация труда по преобразованию, труд через установление порядка;
-- `(атом ...)` -- контекст организации протонов и нейтронов, создание сложных форм материи;
-- `(если ...)` -- контекст поиска сущего в практике, реализация диалектики бытия;
-- `(... @система ...)` -- свойство, задающее условия существования предельно конкретной истины, ограничивает границы возможного конкретного предметного труда
+- `фн: ...` -- контекст декларации (организация труда по преобразованию, труд через установление порядка);
+- `атом: ...` -- контекст декларации (организация протонов и нейтронов, создание сложных форм материи);
+- `если ...` -- контекст применения (поиск сущего в практике, реализация диалектики бытия);
+- `- система` -- эффект, задающий условия существования предельно конкретной истины, ограничивает границы возможного конкретного предметного труда
 
 > 💡 **Контекст** — это границы процесса и руководящая роль в процессе, его пространство возможного: как управляющий центр организует ресурсы, руководит исполнением, контролирует процесс и определяет форму результата процесса, но не конкретный результат процесса.
 
-## Круглые скобки — диалектическая граница состояний
+## Блок — диалектическая граница состояний
 
-Скобки — не просто синтаксис, они — отражение закона перехода количества в качество.
+Блок — не просто синтаксис, он — отражение закона перехода количества в качество.
 
-До скобок:
+До блока:
 
 - Данные — потенциальность,
 - Функция — возможность.
 
-Внутри скобок: проявление борьбы и единства противоположностей:
+Внутри блока: проявление борьбы и единства противоположностей:
 
 - данные и алгоритм,
 - память и процессор,
 - декларация и действие.
 
-После скобок:
+После блока:
 
 - Результат — новое качество,
 - Состояние изменилось — развитие произошло.
-- Скобки — не разделители, они — граница скачка, момент, когда количество (аргументы, посредством алгоритмов) переходит в качество (результат).
+- Блок — не разделитель, он — граница скачка, момент, когда количество (аргументы, посредством алгоритмов) переходит в качество (результат).
 
 ## Единая форма для всех процессов — отражение единства бытия
 
-Отказ от множества синтаксисов (как в `Rust`, `Pascal`, `Python`) в пользу единой формы `(%контекст ...)` — это пример диалектического решения.
+Отказ от множества синтаксисов (как в `Rust`, `Pascal`, `Python`) в пользу единой формы `%контекст: ...` — это пример диалектического решения.
 
 ### Вычисление
 
-```prolet
-(фн CложитьКм (Км a Км b) Км(
-    (Слож a b)
-    (вернуть рез)
-    )
-)
+```yml
+фн:
+  имя: CложитьКм
+  парам:
+    - Км a b
+  вых:
+    - Км
+  нач:
+    - Км слож a b
+    - .. рез
 ```
 
 ## Определение атома (структуры)
 
-```prolet
-(атом Пользователь
-    @имя     Имя
-    @возраст Возраст)
+```yml
+атом:
+  имя: Пользователь
+  протон:
+    - Имя     имя     +эксп
+    - Возраст возраст
 ```
 
 ## Условие
 
-```prolet
-(если (Сравнить x > 0)
-    тогда (Напечатать "положительно"))
+```yml
+нач:
+  - Цел срав x > 0
+  - если рез
+  - _ тогда Напечатать "положительно")
 ```
 
 ## Цикл
 
-```prolet
-(для x в Данные
-    (Удвоить х)(уст результат)
-    (ОтправитьПоПочте результат))
+```yml
+нач:
+ - Цикл Данные шаг 2 Цел удвоить рез
+ - ОтправитьПоПочте рез
 ```
 
 ## Диалектический процесс творчества
@@ -99,59 +113,64 @@
 
 > 💡 Это — единство противоположностей в синтаксисе: разные по смыслу операции — объединены границей конкретного контекста.
 
-## Почему именно круглые скобки? Материалистическое обоснование
+## Почему именно блоки? Материалистическое обоснование
 
-Не фигурные, не квадратные, не без скобок — именно круглые.
+Не фигурные скобки, не квадратные, не скобки — именно блоки.
 
-- Они замкнуты — отражают целостность процесса, `всё имеет своё начало и свой конец`.
-- Нет углов — символизируют бесконечность форм движения в рамках единого бытия.
+- Они ограничены — отражают целостность процесса, `всё имеет своё начало и свой конец`,
+- Они имеют разный размер — символизируют бесконечность форм движения в рамках единого бытия,
+- Они имеют вложенность — прямое отражение структурированности мира.
 
-Скобки опираются на S-выражения, но это не традиция `Лиспа`, это не повторение его, а диалектическое развитие:
+Блоки опираются на S-выражения, но это не традиция `Лиспа`, это не повторение его, а диалектическое развитие:
 
 - У **Лиспа**: `(выражение)` — имеет невыразительную форму, часто архаично и местами нарушает единый подход.
-- В **prolet**: `(%контекст ...)` — наделяется одной формой, но разными смыслами.
-- Круг — форма завершённого движения. В нём нет начала и конца — только непрерывное движение с заключённым в него развитием и переходом в рамках одной всеобщей формы.
+- В **prolet**: `%контекст: ...` — наделяется одной формой, но разными смыслами.
+- Блок — форма завершённого движения. В нём нет есть начало и есть конец — только непрерывное движение с заключённым в него развитием и переходом в рамках одной всеобщей формы.
 
 ## Архитектурные последствия решения
 
 ### Все конструкции — процессы и функции
 
-Даже определение протонов и нейтронов — не декларация, а процесс создания категории бытия.
+Даже определение протонов и нейтронов — не просто декларация, а процесс создания категории бытия.
 
 Даже комментарий — является процессом:
 
-```prolet
-(// Этот модуль отвечает за безопасность пользователей)
+```yml
+# Этот модуль отвечает за безопасность пользователей
 ```
 
-В данном случае, комментарий -- это не физически выполняемый контекст, а контекст на этапе компиляции, который при оптимизированный сборке может быть полностью исключён после итоговой сборки программы.
+В данном случае, комментарий -- это физически выполняемый контекст, но не этапе исполнения, а выполняемый контекст на этапе компиляции, который при оптимизированный сборке может быть полностью исключён после итоговой сборки программы.
 
 Также определение протонов и нейтронов, атомов и спецификаций -- это процессы на этапе компиляции, которые могут быть оптимизированы и исключены в финальной сборке.
 
-| Элемент                   | Этап компиляции                                   | Этап выполнения  | Влияние на бинарный файл |
-| -------------------------------- | --------------------------------------------------------------- | ------------------------------ | --------------------------------------------- |
-| **Комментарий** | Генерация документации                     | ❌ Не выполняется | ❌ Исключается                     |
-| **Атом**               | Статическая проверка, оптимизация | ❌ Не выполняется | ✅ Оптимизирован                 |
-| **Спецификация**    | Статическая проверка                         | ❌ Не выполняется | ✅ Сохраняется                     |
-| **Код**                 | Генерация бинарного файла                | ✅ Выполняется      | ✅ Сохраняется                     |
+| Элемент         | Этап компиляции     | Этап выполнения  | Влияние на бинарный файл |
+| --------------- | -------------------------- | ----------------- | ---------------- |
+| **Комментарий** | Генерация документации     | ❌ Не выполняется | ❌ Исключается   |
+| **Атом** | Статическая проверка, оптимизация | ❌ Не выполняется | ✅ Оптимизирован |
+| **Спецификация** | Статическая проверка      | ❌ Не выполняется | ✅ Сохраняется   |
+| **Код**          | Генерация бинарного файла | ✅ Выполняется    | ✅ Сохраняется   |
 
 ### Нет "пассивного кода"
 
-Всё, что в скобках — должно быть исполнено, даже если эффект — регистрация, документирование, проверка.
+Всё, что в блоке — должно быть исполнено, даже если эффект — регистрация, документирование, проверка.
 
 ## Расширяемость через контексты
 
 Новый тип контекста — новая форма организации труда. Пример:
 
-```prolet
-(ПрцПарал ОбогатитьДанные
-    (загрузить)
-    (индексировать))
-
-(прц ОбновитьСчёт(
-    (обновить-счёт)
-    (отправить-уведомление))
-)
+```yml
+прц:
+  имя: Пуск +эксп
+  нач:
+    - ПрцПарал ОбогатитьДанные
+    - Загрузить
+    - Индексировать
+
+прц:
+  имя: ОбновитьСчёт
+  нач:
+    - ОбновитьСчёт
+    - ОтправитьУведомление
 ```
 
 Язык не растёт за счёт синтаксиса, а за счёт семантики контекстов.
@@ -160,9 +179,9 @@
 
 Для новичка:
 
-- Легко запомнить: всё — в скобках, первое — что возможно сделать.
+- Легко запомнить: всё — в блоках, первое — что возможно сделать.
 - Не нужно учить 10 синтаксисов.
-- Учится мыслить процессуально, а не декларативно. В конкретных материальных условиях.
+- Учится мыслить как процессуально, так и декларативно. В конкретных материальных условиях.
 
 Для мастера:
 
@@ -170,25 +189,25 @@
 - Может анализировать потоки, оптимизировать, рефакторить;
 - Может бесшовно расширять ядро языка.
 
-## 🎯 Заключение: (%контекст ...) как онтологическая аксиома `prolet`
+## 🎯 Заключение: %контекст: ... как онтологическая аксиома `prolet`
 
 > ✅ Текущее синтаксическое решение — не техническое, но — философское, политическое, революционное.
 
-`(%контекст ...)` — это материалистическая формула вычисления:
+`%контекст: ...` — это материалистическая формула вычисления:
 
 - Контекст — знание мира, форма организации действия, руководство процессом,
 - Аргументы — материя, подлежащая преобразованию,
-- Скобки — граница процесса, скачок, развитие.
+- Блок — граница процесса, скачок, развитие.
 
 > 💡 Это — не синтаксис, это — закон языка,
 
 - как закон перехода количества в качество,
 - закон отрицания отрицания,
-- закон единства и борьбы противоположностей.
+- закон единства и борьбы противоположностей (декларация и действие).
 
 ### Декларация
 
-- В языке **prolet** всякая конструкция есть *контекст*.
-- Всякий *контекст* начинается с имени и заключён в круглые скобки.
-- Контекст определяет границы и смысл, скобки — форму движения.
+- В языке **prolet** всякий блок есть *контекст*.
+- Всякий *контекст* начинается с имени и заключён в соответствующий отступ.
+- Контекст определяет границы и смысл, отступ — форму декларации и движения.
 - Нет контекста — нет и конкретного бытия.

docs/docs/01_60.md

@@ -14,33 +14,33 @@
 
 Нам же нужен синтез:
 
-- Минимализм `Lisp` в синтаксисе,
-- Материализм диалектики в семантике,
-- Педагогика в структуре,
-- Развитие — в самом языке.
+* Минимализм `Lisp` в синтаксисе,
+* Материализм диалектики в семантике,
+* Педагогика в структуре,
+* Развитие — в самом языке.
 
 ### Новый путь: `prolet` как диалектический минимализм
 
 Основной принцип:
 
-- Один синтаксис — множество контекстов.
-- Форма — минимальна,
-- Смыслы — управляемы контекстом,
-- Развитие — через метаязык.
+* Один синтаксис — множество контекстов.
+* Форма — минимальна,
+* Смыслы — управляемы контекстом,
+* Развитие — через метаязык.
 
 Это — не возврат к `Lisp` , а его диалектическое преодоление:
 
-- мы берём гомоиконичность (взаимность представления кода и данных),
-- макросы,
+* мы берём гомоиконичность (взаимность представления кода и данных),
+* макросы,
 
-но встраиваем их в рамки объективной реальности — памяти, времени, безопасности, готовности программиста.
+но встраиваем их в рамки объективной реальности — памяти, времени, безопасности, единообразия, готовности программиста.
 
 ## Единая синтаксическая форма: S-выражения с семантической дисциплиной
 
 Вместо множества форм ( `struct` , `enum` , `fn` , `unsafe` , `impl` , `where` и т.д.) — одна базовая конструкция:
 
-```prolet
-(%контекст ...)
+```yml
+%контекст: ...
 ```
 
 **Но!** Семантика определяется *не формой*, а *контекстом* и *свойствами контекста*.
@@ -48,80 +48,113 @@
 Примеры:
 Функция (высокий уровень)
 
-```prolet
-(фн Обработать (Байты данные)
-    (Фильтровать данные (> 10) (* 2))
-)
+```yml
+фн:
+  имя: Обработать
+  парам:
+    - Байты данные
+  нач:
+    - Фильтровать данные (> 10) (* 2)
 ```
 
 Низкоуровневая операция
 
-```prolet
-(фн Копировать  @система(
-		CисАдрес ист
-		CисАдрес цель
-		Дом размер)(
-	(кварк
-		(ЦиклОт ист до цель (
-			(загр ист рег0)
-			(слож рег1 рег0)
-			(сохр рег1 цель))
-	))
-)
+```yml
+прц:
+  имя: ЦелПеремещ
+  эффект:
+    - система
+    - кварк
+  парам:
+    - КваркЦел ист цель +изм
+  нач:
+    - Загр ист рег0
+    - Слож рег1 рег0
+    - Сохр рег1 цель
+
+прц:
+  имя: Копировать
+  парам:
+    - CисАдрес ист цель
+    - Дом размер
+  нач:
+    - Цикл ист до цель ЦелПеремещ рез
 ```
 
 ### Атомы
 
-```prolet
-(атом Пользователь
-    @имя      ЧеловекИмя
-    @возраст  ЧеловекВозраст
-    @роль     Роль
-)
+```yml
+атом:
+  имя: Пользователь
+  протон:
+    - ЧеловекНом     номер
+    - ЧеловекИмя     имя     +изм
+    - ЧеловекВозраст возраст +изм
+    - Роль           роль    +изм
 ```
 
 Спецификация
 
-```prolet
-(спец ИФайл
-    (Читать (ФайлИмя имя) РезБайты
-      @_док "Читает файл с указанным именем")
-    (Писать (ФайлИмя имя Ос.Права права ) ОптОш @изм
-        @_док "Записывает файл с указанным именем и правами")
-)
+```yml
+спец:
+  имя: ИФайл
+  действ:
+    Читать:
+      тип: прц
+      парам:
+        - ФайлИмя имя
+      вых:
+        - РезБайты
+      док: "Читает файл с указанным именем"
+    Писать:
+      тип: прц
+      парам:
+        - ФайлИмя имя
+        - Ос.Права права
+      вых:
+      - ОптОш +изм
+      док: "Записывает файл с указанным именем и правами"
 ```
 
 Все конструкции — одного синтаксического вида, но семантика управляется *контекстом в начале*:
 
-- `фн` (функция),
-- `атом` ,
-- `система` (низкоуровневый),
-- `спец`.
+* `фн` (функция),
+* `атом` ,
+* `система` (эффект, низкоуровневый),
+* `спец`.
 
 ## Узкие семантические формы: от простого к сложному
 
-`Мы не устраняем сложность, но последовательно её раскрываем.`
+ `Мы не устраняем сложность, но последовательно её раскрываем.`
 
 ### Уровень 1: Новичок
 
 Доступны только:
 
-- (прц ...)
-- (фн ...)
-- (атом ...),
-- (словарь ...),
-- (если ...),
-- (для ...)
+* прц: ...,
+* фн: ...,
+* протон: ...,
+* протон: ...,
+* словарь: ...,
+* список: ...,
+* если ...,
+* цикл ...
 
 Нет доступа к:
 
-- (@система),
-- (кварк),
-- (макро).
-
-```prolet
-(фн Приветствовать (ГостьИмя имя)
-  (Печатать "Привет, " имя "!"))
+* `система` (эффект, низкоуровневый),
+* `кварк` (эффект, низкоуровневый),
+* `макро` (эффект, низкоуровневый, манипуляция AST).
+
+```yml
+прц:
+  имя: Приветствовать
+  эффект:
+    - терм_вых
+  парам:
+    - ГостьИмя имя
+  нач:
+    - Печатать "Привет, " имя "!"
 ```
 
 Простота **Лиспа**, но в безопасной оболочке диалектического языка.
@@ -130,21 +163,15 @@
 
 Открываются:
 
-- (атом ...)
-- (спец ...)
-- (макрос ...)
-- (форма ....)
-
-```prolet
-(атом Точка
-    @x ПозX
-    @y ПоpY)
-
-(макрос когда (условие тело)
-  (если условие
-    тогда (Выполнить тело)
-    иначе (Выполнить тело))
-)
+* атом: ...,
+* спец: ...,
+
+```yml
+атом:
+  имя: Точка
+  протон:
+    - ПозX х
+    - ПозУ у
 ```
 
 Язык начинает развиваться, но в рамках контролируемой системы.
@@ -153,44 +180,76 @@
 
 Разрешён:
 
-- (@система ...)
-- (кварк ...)
-- (система-вызов ...)
-- (адр ...)
-
-```prolet
-(прц @система КопироватьПамять (
-      СисАдр цель
-      СисАдр источник @изм
-      СисКолич длина)(
-  (кварк (сохр рег3 длина))
-    (кварк (ЦиклОт рег0 до рег2
-      (...))
-  ))
-)
+* `система` (низкоуровневый эффект)
+* `кварк` (низкоуровневый эффект)
+* Система <вызов> (работа на уровне ВМ)
+* `адр` (работа на уровне ВМ)
+* макро: ... (манипуляция AST)
+
+```yml
+макрос:
+  имя: когда
+  парам:
+    - тело условие
+    - тело кодДа
+    - тело кодНет
+  эффект:
+    - квалификация специалист
+    - тест
+  док: "Удобный макрос-обёртка над если"
+  нач:
+    - если условие
+    - _ тогда {кодДа}
+    - _ иначе {кодНет}
+
+прц:
+  имя: КопироватьПамять
+  эффект:
+    - система
+    - кварк
+    - квалификация специалист
+    - тест
+  парам:
+    - СисАдр цель источник +изм
+    - СисКолич длина
+  нач:
+    - Сохр рег3 длина
+    - Цикл рег0 до рег2 ЦельПеремещ рег0
 ```
 
 **Но!** Такой код не компилируется без:
 
-- одобрения ревью,
-- ссылки на стандарт (например, "форма драйвера PCI"),
-- пометки обоснования `@причина` "взаимодействие с железом".
+* одобрения ревью,
+* ссылки на стандарт (например, "форма драйвера PCI"),
+* пометки обоснования `причина` "взаимодействие с железом".
 
 ## Семантическая экономия: один синтаксис — разный смысл по контексту
 
-```prolet
-(спис 1 2 3)
-(атом Пользователь)
-(выраж ...)
-(спец Проверятор)
-(список Цел 1 2 3)
-(атом ПользовательНов
-  @имя     "Анна"
-  @возраст 28
-  @роль    Админ)
-(уст ...)
-(<ИмяФункции>)
-(ЕслНечто нечто как ИФайл)
+```yml
+спис: Цел 1 2 3
+атом:
+  имя: Пользователь
+  протон:
+    - ЧелИмя     имя
+    - ЧелВозраст возраст +изм
+    - Роль       роль    +изм
+спец:
+  имя: Проверятор
+прц:
+  имя: Пуск
+  нач:
+    - ПользовательНов
+    - _  имя     "Анна"
+    - _  возраст 28
+    - _  роль    Админ
+    - уст ...
+фн:
+  имя: ФайлПроверить
+  парам:
+    - СписБайт нечто
+  нач:
+    - нечто .длина > 0
+    - если рез Файл записать нечто
 ```
 
 Это — диалектическая гибкость: форма одна, но смысл возникает в практике применения, а не в синтаксической избыточности.
@@ -199,21 +258,26 @@
 
 Макросы — не анархия, а организованное развитие.
 
-```prolet
-(макрос конкурент (тело...)
-  (поток (тело))
-  @_док "Запускает конкурентно тело выражения")
-
-(конкурент
-  (ЗагрузитьДанные)
-  (ОбновитьИнтерфейс))
+```yml
+макрос:
+  имя: конкурент
+  парам:
+    - тело код
+  нач:
+  - поток {код}
+  - док: "Запускает конкурентно тело выражения"
+
+прц:
+  имя: Пуск
+  нач:
+    - конкурент ЗагрузитьДанные ОбновитьИнтерфейс
 ```
 
 Но:
 
-- Макросы только в модулях уровня 2+,
-- Должны быть задокументированы,
-- Не могут переопределять базовые формы (`если`,  `фн` и т.п.).
+* Макросы только в модулях уровня 3+,
+* Должны быть задокументированы,
+* Не могут переопределять базовые формы (`если`,  `фн` и т.п.).
 
 Это — революционное преобразование старой формы со свободным содержанием, в новую форму с дисциплиной смысла.
 
@@ -221,77 +285,84 @@
 
 Переход на низкий уровень — не синтаксическое волшебство, а сознательный акт:
 
-```prolet
-(фн @система СложитьАдреса (СисАдр a СисАдр b)
-  @_обоснование "оптимизация критического участка"
-  @_требует_ревью
-  @_уровень_доступа 3
-    (Сложить (СисИзвлечь a)
-             (СисИзвлечь b))
-)
+```yml
+фн:
+  имя: СложитьАдреса
+  эффект:
+    - система
+    - обоснование "оптимизация критического участка"
+    - ревью
+    - квалификация специалист
+  парам:
+    - СисАдр a b
+  нач:
+    - РодИзвлечь a
+    - РодИзвлечь b
+    - Яблоко сложить a b
 ```
 
 Что даёт такая форма:
 
-- Семантически сужает контекст: только указатели, только арифметика.
-- Фиксирует ответственность: обоснование, ревью, уровень.
-- Экономит мыслетопливо: нет лишних слов, только суть.
-- Педагогически настраивает: программист осознаёт, что делает.
+* Семантически сужает контекст: только конкретные ссылки, только арифметика;
+* Фиксирует ответственность: обоснование, ревью, квалификация;
+* Экономит мыслетопливо: нет лишних слов, только суть;
+* Педагогически настраивает: программист осознаёт, что делает;
+* Эффекты "вниз" (скрыты), эффекты вверх (принуждения).
 
 ## Сравнение подходов: почему это диалектичнее
 
 ### Синтаксическая сложность
 
-- `Lisp` Очень низкая
-- `Rust` Высокая
-- `prolet` Низкая
+* `Lisp` Очень низкая
+* `Rust` Высокая
+* `prolet` Низкая
 
 ### Семантическая ясность
 
-- `Lisp` Низкая (всё — список)
-- `Rust` Высокая (много форм)
-- `prolet` Высокая (контекст + действие)
+* `Lisp` Низкая (всё — список)
+* `Rust` Высокая (много форм)
+* `prolet` Высокая (контекст + действие)
 
 ### Гибкость
 
-- `Lisp` Деструктивно высокая
-- `Rust` Ограниченная
-- `prolet` Высокая (макросы + уровни)
+* `Lisp` Деструктивно высокая
+* `Rust` Ограниченная
+* `prolet` Высокая (макросы + уровни)
 
 ### Безопасность
 
-- `Lisp` Нет
-- `Rust` Высокая
-- `prolet` (по уровням, от минимальной до высокой)
+* `Lisp` Нет
+* `Rust` Высокая
+* `prolet` (по уровням, от минимальной до высокой)
 
 ### Развитие языка
 
-- `Lisp`  доступно индивидуально
-- `Rust` Через RFC
-- `prolet` Через макросы + одобрение сверху
+* `Lisp`  доступно индивидуально
+* `Rust` Через RFC
+* `prolet` Через макросы + одобрение сверху
 
 ### Экономия мыслетоплива
 
-- `Lisp` Высокая для экспертов, низкая для новичков
-- `Rust` Низкая (много правил)
-- `prolet` Высокая для всех (одна форма; много разных смыслов в разных контекстах)
+* `Lisp` Высокая для экспертов, низкая для новичков
+* `Rust` Низкая (много правил)
+* `prolet` Высокая для всех (одна форма; много разных смыслов в разных контекстах)
 
 ### Педагогичность
 
-- `Lisp` Низкая
-- `Rust` Недостаточная
-- `prolet` Высокая (постепенное раскрытие)
+* `Lisp` Низкая
+* `Rust` Недостаточная
+* `prolet` Высокая (постепенное раскрытие)
 
 ## 🎯 Заключение: язык как диалектический инструмент
 
 Приведённый синтез формы из трёх языков, соответствует духу диалектического материализма:
 
-- Форма — лисп-подобная: одна, чистая, минимальная.
-- Семантика — материалистическая: определяется практикой, контекстом, уровнем развития.
-- Переход между уровнями — не скачок, а педагогически организованный процесс.
-- Язык — не замороженный объект, а развивающийся организм.
+* Форма — лисп-подобная: одна (по сути), чистая, минимальная.
+* Семантика — материалистическая: определяется практикой, контекстом, уровнем развития.
+* Переход между уровнями — не скачок, а педагогически организованный процесс.
+* Язык — не замороженный объект, а развивающийся организм.
 
 Это — не упрощение, а углубление диалектики:
 
-- мы не множим формы,
-- мы углубляем понимание единства и борьбы противоположностей в самом акте программирования.
+* мы не множим формы,
+* мы углубляем понимание единства и борьбы противоположностей в самом акте программирования.

docs/docs/01_70.md

@@ -41,19 +41,28 @@
 
 Основано на S-выражениях, как в **Лиспе**, но семантически строго:
 
-```prolet
-(// Если не указан атрибут изменяемости -- по умолчанию @фикс)
-(фн Cложить (Час a Час b)(
-    (Час Сложить a b))
-)
-
-(атом Пользователь
-    @имя     ЧеловекИмя
-    @возраст ЧеловекВозраст)
-
-(если (Сравнить x > 0)
-  тогда (Напечатать "Положительно")
-  иначе (Напечатать "Ноль или отрицательно"))
+```yml
+# Если не указан атрибут изменяемости -- по умолчанию фикс
+фн:
+  имя: Cложить
+  парам:
+    - Час a b
+  нач:
+    - Час сложить a b
+
+атом:
+  имя: Пользователь
+  протон:
+    - ЧеловекИмя имя
+    - ЧеловекВозраст возраст
+
+прц:
+  имя: Пуск
+  нач:
+    - Цел сравнить х > 0
+    - если рез
+    - _ тогда Напечатать "Положительно"
+    - _ иначе Напечатать "Ноль или отрицательно"
 ```
 
 Особенности ядра:
@@ -67,20 +76,35 @@
 
 ## Расширение: творческое, подвижное, диалектическое
 
-Работает в таких же круглых скобках, где сопровождающий контекст `макро` означает расширение, развитие, отрицание старого на уровне пользователя. Расширение способно заменить в текущей программе более высокоуровневые реализации.
+Работает в таких же блоках, где сопровождающий контекст `макро` означает расширение, развитие, отрицание старого на уровне пользователя. Расширение способно заменить в текущей программе более высокоуровневые реализации.
 
 Внутри — новые формы, **DSL**, макросы, оптимизации. Снаружи -- прежний синтаксис.
 
-```prolet
-(макро параллельно (
-  (ЗагрузитьДанные)
-  (ОбновитьИнтерфейс))
-)
-
-(макро SQL "SELECT * FROM пользователи WHERE возраст > ?" возраст )
+```yml
+макро:
+  имя: параллельно
+  эффект:
+    - тест
+    - ядро
+  автор: user@ya.ru
+  док: "Конструктор запроса SELECT"
+  парам:
+    - тело данные
+    - тело спека
+  нач:
+    - ЗагрузитьДанные {данные}
+    - ОбновитьСпек {спека}
+
+макро:
+  имя: выбор
+  парам:
+    - тело таблица
+    - тело возраст
+  нач:
+    - SQL "SELECT * FROM {пользователь} WHERE возраст > ?" {возраст}
 ```
 
-Как это работает: `параллельно` — не ключевое слово, а расширение, определённое в пользовательской библиотеке, на том же уровне.
+Как это работает: `параллельно` — не ключевое слово, а расширение, определённое в пользовательской библиотеке, на том же уровне. Эффект `ядро` запрещает переопределять или изменять макрос.
 
 Это — народное творчество, как массовое движение, которое не ломает основу, но вносит новое содержание.
 
@@ -90,8 +114,8 @@
 
 ### Формы ядра
 
-- Форма: `(%контекст %действие %аргументы)`
-- Изменяемость: Запрещена в версии
+- Форма: `%контекст: ...`
+- Изменяемость: Запрещена в версии (эффект `ядро`)
 - Компиляция: На этапе 1
 - Авторство: разработчики ядра
 - Ответственность: Гарантирована
@@ -99,12 +123,12 @@
 
 ### Формы пользователя
 
-- Форма: `(макро содержание)`
+- Форма: `макро: ...`
 - Изменяемость: Разрешена, по согласованию
 - Компиляция: На этапе 2 (после ядра, но до разбора исходного текста)
 - Авторство: Сообщество, отдельные разработчики
 - Ответственность: На авторе расширения
-- Жизненный цикл: Краткий (пробный, экспериментальный))
+- Жизненный цикл: Краткий (пробный, экспериментальный)
 
 Это — диалектическое разделение труда в языке:
 
@@ -116,35 +140,40 @@
 
 Пример: появление нового цикла в потоках (старое ядро):
 
-```prolet
-(для задача в списокЗадач
-    (СоздатьПоток задача))
+```yml
+прц:
+  имя: Пуск
+  нач:
+    - ЦиклПо списокЗадач СоздатьПоток рез
 ```
 
 После проверки практикой — включение в ядро новой версии (расширение):
 Новое (расширение):
 
-```prolet
-(параллельно (Выполнить списокЗадач))
+```yml
+прц:
+  имя: Пуск
+  нач:
+    - параллельно Выполнить списокЗадач, Печать "Параллельная печать в терминал!"
 ```
 
 Это — отрицание отрицания:
 
-- Старое `(для ... СоздатьПоток)` — отрицается,
-- Новое `(параллельно ...)` — отрицает старое,
+- Старое `ЦиклПо ... СоздатьПоток` — отрицается,
+- Новый макрос `параллельно ...` — отрицает старое,
 
-Но затем `(параллельно ...)` само отрицается — становится частью ядра, и появляется новое расширение для асинхронных потоков.
+Но затем `параллельно ...` само отрицается — становится частью ядра, и появляется новое расширение для асинхронных потоков.
 
 ## Психологическая и педагогическая выгода
 
 Для новичка:
 
-- Видит только `(...)` — простота, порядок, безопасность.
+- Видит только `%контекст: ...` — простота, порядок, безопасность.
 - Расширения скрыты или отключены.
 
-Для мастера:
+Для специалиста:
 
-- Может писать `(макро ...)`, на пользовательском уровне, но осознаёт, что это — эксперимент, что он выходит за рамки устоявшегося, что за это несёт ответственность. При компиляции получает уведомление (если не подавлено атрибутом).
+- Может писать `макро: ...`, на пользовательском уровне, но осознаёт, что это — эксперимент, что он выходит за рамки устоявшегося, что за это несёт ответственность. При компиляции получает уведомление (если не подавлено атрибутом).
 
 Расширения разработчиками ядра могут быть:
 
@@ -163,11 +192,13 @@
 
 Этап 2: Макро-раскрытие расширений на уровне пользователя
 
-- Находит `(макро ...)`, подставляет определение из зарегистрированных расширений.
+- Находит `макро: ...`, подставляет определение из зарегистрированных расширений;
+- Проверяет квалификацию, тесты, отсутствие эффекта `ядро`.
 
 Этап 3: Трансляция в ядро
 
-- Все пользовательские макросы интегрируются в ядро.
+- Все пользовательские макросы интегрируются в ядро;
+- Проставляется эффект `ядро`.
 
 Этап 4: Компиляция
 
@@ -178,34 +209,49 @@
 
 ## Пример полного кода
 
-```prolet
-(// === ЯДРО === )
-(фн ОбработатьПакет (СписокДок пакет)(
-    (если (ПроверитьЦелостность пакет)
-        тогда (Расшифровать пакет)
-        иначе (Остановить "битый пакет")
-  ))
-)
-
-(// === РАСШИРЕНИЕ === )
-(атом ВебСервер
-  @маршрут ВебОбработчик
-  @порт    СетьПорт
-)
-
-(Печатать "Запуск сервера...")
+```yml
+# === ЯДРО ===
+фн:
+  имя: ОбработатьПакет
+  эффект:
+    - ядро
+  парам:
+    - СписокДок пакет
+  нач:
+    - ПроверитьЦелостность пакет
+    - если рез
+    - _ тогда Расшифровать пакет
+    - _ иначе Остановить "битый пакет"
+
+# === РАСШИРЕНИЕ ===
+атом:
+  имя: ВебСервер
+  протон:
+    - ВебОбработчик маршрут
+    - СетьПорт порт
+
+прц:
+  имя: Пуск
+  нач:
+    - Печатать "Запуск сервера..."
 ```
 
 Здесь:
 
-- (фн ...) — ядро, стабильно,
-- (ВебСервер ...) — использование результатов творчества, может измениться,
-- (Печатать ...) — может быть переопределён под нужды среды, вместо реализации ядра
+- `фн: ...` — ядро, стабильно,
+- `ВебСервер` — использование результатов творчества, может измениться,
+- `Печатать ...` — может быть переопределён под нужды среды, вместо реализации ядра
+
+### Правила
+
+- Сущности ядра могут использовать сущности этапа разработки через спецификации;
+- Сущности ядра на этапе разработки изменять нельзя;
+- Сущности этапа разработки могут использовать сущности ядра.
 
 ## 🎯 Заключение: язык как диалектическая система
 
-- Форма ядра `(...)` — отражает устоявшееся, необходимое, объективное.
-- Форма расширения — `(макро ...)` — отражает возникающее, творческое, субъективное.
+- Форма ядра `%контекст: ...` — отражает устоявшееся, необходимое, объективное.
+- Форма расширения — `макро: ...)` — отражает возникающее, творческое, субъективное.
 
 > ✅ Их борьба и единство — двигатель развития.
 

docs/docs/01_80.md

@@ -1,4 +1,4 @@
-# pro.01_80 Диалектика динамики типов
+# pro.01_80 Диалектика динамики обобщений
 
 Рассмотрим более подробно ещё одно диалектическое противоречие: "статическая типизация -- динамическая типизация". Надо получить ясный, структурированный переход между строгой статикой и высокой динамикой. А также предусмотреть контролируемый механизм перехода из одного состояния в другое.
 
@@ -30,7 +30,7 @@
 
 > 💡 Победа — в синтезе, в контролируемом переходе от одной формы к другой, в зависимости от объективных условий задачи.
 
-**Цель**: `диалектическая типизация`
+**Цель**: `диалектическое обобщение`
 
 Не смешение статики и динамики, а их единство в движении, где:
 
@@ -38,11 +38,11 @@
 - Динамика — вынужденное отклонение,
 - Переход — не хаос, а сознательный, контролируемый, документируемый акт.
 
-## Основные принципы диалектической типизации
+## Основные принципы диалектического обобщения
 
 ### Статика по умолчанию
 
-Вся переменные, функции, атомы — строго типизированы.
+Вся переменные, функции, атомы — статически обобщены.
 
 ### Динамика — как отрицание нормы
 
@@ -55,6 +55,8 @@
 
 Из динамики можно выйти только через проверку и приведение типа.
 
+> Здесь и далее тип понимается не как абстракция, а как обобщение конкретного
+
 ### Контекст определяет
 
 - В ядре системы — только статика.
@@ -64,74 +66,90 @@
 
 Новичок не может использовать динамику без одобрения.
 
-## Механизм перехода: "@вход"
+## Механизм перехода: эффект "вход"
 
-Введём новую конструкцию — `@вход`, которая ограничивает пространство и время действия динамики.
+Введём новую конструкцию — `вход`, которая ограничивает пространство и время действия динамики.
 
-`@вход` -- это форма диалектического преодоления несовершенства внешнего мира.
+Эффект `вход` -- это форма диалектического преодоления несовершенства внешнего мира.
 
-`@вход`, `@выход` — это не просто синтаксический сахар, это — граница между мирами, между упорядоченным миром `prolet` и хаосом внешних данных, между типизированным бытием и бестиповым небытием.
+`вход`, `выход` — это не просто синтаксический сахар, это — граница между мирами, между упорядоченным миром `prolet` и хаосом внешних данных, между конкретным внутренним бытием и (возможно) неразличимым внешним бытием.
 
 Входы и выходы всегда требуется при обмене с внешним миром. Если приём данных из внешнего источника из экосистемы `prolet` -- тогда такой поток байтовых данных будет сопровождаться метками типа. В этой ситуации контроль на входе не нужен.
 
-```prolet
-(// Внутри — следует использовать байтовый поток,
-    тип на выходе -- `нечто`)
-(Веб Запросить "/data" @вход
-    @требует_ревью)(уст нечто)
-(// тип: фиксированный срез байтов)
-
-(// Обратный переход — только через проверку)
- (ЕслиНечто нечто как Пользователь
-    тогда ((Привести нечто к Пользователь)
-        (уст пользователь))
-    иначе (ПечатьОшибка "неверный формат")
-)
+```yml
+# Внутри — следует использовать байтовый поток, тип на выходе -- СписБайт
+прц:
+  имя: ВебЗапрос
+  эффект:
+    - вход
+    - ревью
+  вых:
+    - СрезБайт
+  нач:
+    - Веб запросить "/data"
+    # тип: фиксированный срез байтов
+    - <...>
+
+# Обратный переход — только через проверку
+прц:
+  имя: Пуск
+  нач:
+   - ВебЗапрос
+   - уст ответ
+   - СрезБайт еслиОк ответ
+   - если рез
+   - _  тогда Пользователь изБайт ответ
+   - _  иначе ПечатьОшибка "неверный формат"
 ```
 
 Особенности входа:
 
 - всегда принимает поток байт;
-- прекращает работу, если свойство `@вход` не указано, а формат байтового потока не имеет меток типов полей;
+- не компилируется, если эффект `вход` не указано, а формат байтового потока не имеет меток типов полей;
 - Запрещён в критических модулях (ядро, безопасность);
-- Только после ревью (для уровней < 3).
+- Только после ревью (для квалификации ниже специалист).
 
 Это — не либерализм, а учёт требований объективной реальности, как *военный коммунизм → нэп → социализм*.
 
-Суть `@вход`: граница между мирами
+Суть эффекта `вход`: граница между мирами
 
 🌍 Два мира:
 
-| МИР PROLET                                  | ВНЕШНИЙ МИР                                  |
-| ---------------------------------------------- | ------------------------------------------------------ |
-| Типы — первичны                   | Типы — отсутствуют или скрыты |
-| Данные — структурированы | Данные — байтовый поток            |
+| МИР PROLET                   | ВНЕШНИЙ МИР                                  |
+| ---------------------------- | -------------------------------------------- |
+| Типы — первичны              | Типы — отсутствуют или скрыты                |
+| Данные — структурированы     | Данные — байтовый поток                      |
 | Порядок — внутренний         | Хаос — норма                                 |
-| @конст, @фикс, @изм — везде  | Никаких категорий                      |
+| конст, фикс, изм — везде     | Никаких категорий                            |
 
-`@вход` — это не свойство, это — онтологическая граница, где байт становится сущим, а хаос — формой порядка.
+`вход` — это не свойство, это — онтологическая граница, где байт становится сущим, а хаос — формой порядка.
 
 ## Динамический тип, как переходное состояние
 
 Динамический тип — не тип-ловушка, а тип-процесс.
 
-Он не может участвовать в вычислениях напрямую. Чтобы использовать — нужно привести к статическому типу.
-
-```prolet
-(// по умолчанию статичность на выходе @фикс,
-  параметр контакта с внешним миром -- @вход)
-(Api ПолучитьИз)(уст x)
-
-(// Ошибка: (x + 1) — запрещено)
-(ЕслиНечто x как Целое
-    тогда (ОбработатьЧисло (Привести x к Целое))
-    иначе (ПечатьОшибка "ожидалось число")
+Он не может участвовать в вычислениях напрямую. Чтобы использовать — нужно привести к статическому обобщению.
+
+```yml
+# по умолчанию статичность на выходе фикс
+#   эффект с внешним миром -- вход
+прц:
+  имя: Пуск
+  нач:
+    - Api получитьИз
+    - уст x
+    - ВебЗапрос
+    - СписБайт еслиОк х
+    - если рез
+    - _ тогда Целое изБайт x,
+    - _     ОбработатьЧисло
+    - _ иначе ПечатьОшибка "ожидалось число"
 )
 ```
 
 Это — материалистическое требование: чтобы работать с реальностью, нужно понять её структуру.
 
-Если данные пришли от другого `prolet`-процесса, и сериализованы с метаданными (структуры в духе `prolet`), то `@вход` не нужен — это внутренний поток выраженный иными средствами для внешнего хаотического мира, как товарообмен в социалистическом хозяйстве между различными предприятиями в одной цепочке производства и в одной стране, но разных городах.
+Если данные пришли от другого `prolet`-процесса, и сериализованы с метаданными (структуры в духе `prolet`), то эффект `вход` не нужен — это внутренний поток выраженный иными средствами для внешнего хаотического мира, как товарообмен в социалистическом хозяйстве между различными предприятиями в одной цепочке производства и в одной стране, но разных городах.
 
 Но если данные — извне:
 
@@ -140,34 +158,46 @@
 - `CSV`,
 - `XML` с xsi:type="string"
 
-тогда нужен `@вход`, потому что форма несёт в себе противоречие: `байты есть, а типов — нет`.
+тогда нужен эффект `вход`, потому что форма несёт в себе противоречие: `байты есть, а типов — нет`.
 
-## Система приведения типов: "путь к статике"
+## Система приведения обобщений: "путь к статике"
 
 Проверка типа:
 
-- `(ЕслиНечто х как Пользователь)` Булево, безопасно
+- `если рез` Булево, безопасно
 - Безопасное извлечение типа
 
-```prolet
-(ЕслиНечто х как Пользователь
-    тогда (Обработать (Привести х к Пользователь))
-    иначе (ПечатьОшибка "ожидался пользователь")
+```yml
+прц:
+  имя: Пуск
+  вых:
+    - РезПользователь
+  нач:
+    - если рез
+    - _ тогда Пользователь изБайт рез,
+    - _      Обработать
+    - .. рез
 )
 ```
 
-Приведение с проверкой `(Привести х к Пользователь)(уст х @изм)` падает, если не подходит.
+Приведение с проверкой `Пользователь изБайт рез` способно возвращать результат, содержащий ошибку, если не подходит.
 
 ### Функциональный стиль
 
 Схемная валидация для сложных форматов:
 
-```prolet
-(ЕслиНечто байты к Пользователь
-    тогда ((Привести байты в Пользователь)
-           (уст х))
-    иначе (ПечатьОшибка "ожидалось число")
-)
+```yml
+прц:
+  имя: Пуск
+  нач:
+    - ВебЗапрос
+    - уст ответ
+    - СписБайт еслиОк
+    - если рез
+    - _ тогда Пользователь изБайт ответ,
+    - _       уст х
+    - _ иначе Пользователь ошибка "Пуск:" рез .ошибка
+    - .. рез
 ```
 
 Переход из динамики в статику — не автоматический, а требующий сознательного усилия, как переход от чувственного восприятия к рациональному пониманию.
@@ -180,79 +210,104 @@
 
 > 💡 Это — не абсолютизация, а диалектический релятивизм: истина — в конкретной практике, границы которой задаются контекстом.
 
-## Развитие типов: от динамики к статике через практику
+## Развитие обобщений: от динамики к статике через практику
 
 Когда динамический интерфейс стабилизируется, его можно возвысить до статического закона:
 
-```prolet
-(// Сначала — динамически,
-  "ЗапросАпи" определён как @вход, и данные как @фикс)
-(прц ЗапросАпи @вход() нечто(
-  ....)
-)
-(ЕслиНечто нечто как ФорматV1
-    тогда (...)
-    иначе (...)
-)
-
-(// Через месяц практики — выносим в структуру)
-(структ ФорматV1
-  @поле1 НакладнаяНазвание
-  @поле2 СписокЦелое)
-
-(// Использование через приведение, результат определён как @фикс)
-(ЕслиНечто х как ФорматV1
-    тогда ((ЧитатьИз "data/sample.json")
-           (уст конфигТекст))
-)
+```yml
+# Сначала — динамически,
+#  "ЗапросАпи" определён как эффект вход, и данные как фикс
+прц:
+  имя: ЗапросАпи
+  эффект:
+    - вход
+  вых:
+    - СписБайт
+  нач:
+    - <...>
+    # Прямое преобразование
+    # Через месяц практики — выносим в структуру
+    - ФорматV1 изБайт
+    - <...>
+
+# Использование через приведение, результат определён как фикс
+прц:
+  имя: вБайты +эксп
+  парам:
+    - ФормаV1 форма
+  вых:
+    - СписБайт
+  нач:
+    - НакладнаяНазвание вБайт форма .поле1
+    - уст байтПоле1
+    - СписокЦелое вБайт форма .поле2
+    - СписБайт доб байтПоле1 рез
+    - .. рез
+
+атом:
+  имя: ФорматV1 +эксп
+  протон:
+    - НакладнаяНазвание поле1
+    - СписокЦелое поле2
+  нейтрон:
+    - вБайты +эксп
 ```
 
 Это — отрицание отрицания: динамика отрицает статику, но на основе практического действия — порождает заново безопасную статику.
 
-## Почему именно `@вход`, а не просто функция?
+## Почему именно эффект `вход`, а не просто процесс?
 
 Потому что:
 
 - Это — не вычисление,
 - Это — переход количества в качество,
-- Это — восстановление формы из хаоса.
+- Это — восстановление формы из хаоса,
+- Процесс меняет состояние мира, но по заданным законам.
 
 > 💡 Как у диалектики: `Из хаоса — порядок, из количества — качество`.
 
-## Почему `@вход` — однонаправленный?
+## Почему эффект `вход` — однонаправленный?
 
 Потому что:
 
-- Вход — из байт → в типизированное сущее — требует труда, проверки, интерпретации,
+- Вход — из байт → в обобщённое сущее — требует труда, проверки, интерпретации,
 - Выход — из `prolet` → в байты — может быть автоматическим, если используется самоописывающий формат (например, `prolet-bin` с метками типов).
 
-Но если выход — в неструктурированный формат (например, `raw TCP`), то нужен обратный шлюз — `@выход`:
-
-```lisp
-(фн Отправить @выход (Пользователь x)
-    @цель legacy_система(
-   (СериализоватьБезТипов x)
-)
+Но если выход — в неструктурированный формат (например, `raw TCP`), то нужен обратный шлюз — эффект `выход`:
+
+```yml
+прц:
+  имя: Отправить
+  эффект:
+    # указание на вход вне экосистемы prolet
+    - выход +внеш
+  парам:
+    - Пользователь х
+  рез:
+    - СписБайт рез
+  нач:
+   - Пользователь вБайтыВнеш x
+   - .. рез
 ```
 
 Это — единство и борьба: вход и выход — разные по природе, потому что мир в динамике асимметричен.
 
-## Что делает `@вход` на уровне ВМ?
+## Что делает эффект `вход` на уровне ВМ?
 
-При встрече `@вход`:
+При встрече эффекта `вход`:
 
-- Активируется режим проверки:
-- Все значения извне — являются срезом байт.
-- Нельзя использовать напрямую.
+- Активируется режим проверки эффектов во время компиляции:
+- Все значения извне — являются срезом байт;
+- Нельзя использовать напрямую, только в контейнере процесса.
 
 Требуется явное приведение:
 
-- `(Привести х к Пользователь)` → с проверкой.
-- Или — `(ЕслиНечто ... как СхемаХХХ)`.
+- `Пользователь изБайтВнеш ответ` → с проверкой на возможную ошибку;
+- Или — `Пользователь изБайт ответ`, когда такая проверка не требуется.
 
 Фиксируется событие:
 
-- В лог: `(@выход @логОткл)` (по умолчанию активно).
+- В лог: с эффектом `выход +внеш` по умолчанию включено.
 - В граф жизненного цикла — новая ветвь анализа.
 
 ## Психологические и педагогические механизмы
@@ -271,33 +326,44 @@
 
 - Все динамические участки автоматически документируются.
 - Нет идеалистических типов данных (всегда присутствует байтовый поток).
-- При стабилизации — предлагает: "Этот шлюз использован 100 раз. Создать статический тип?" (возможна автоматическая генерация обратимого конвертера)
+- При стабилизации — предлагает: "Этот шлюз использован 100 раз. Создать статическое обобщение?" (возможна генерация обратимого конвертера в виде макроса для подстановки)
 
 ## Пример: полный цикл перехода
 
-```prolet
-(// Внешний API — неизвестная структура)
-(Веб Запросить "https://api.partner/data" @вход)
-(уст нечто)
-
-(// Проверка и переход к статике)
-(ЕслиНечто нечто как АнализДанных)
-    тогда ((Привести нечто в АнализДанных)
-           (уст отчёт @изм)
-           (ОтправитьОтчёт отчёт))
-    иначе (ПечататьОшибку "некорректные данные"))
-
-(// Определение типа на основе практики)
-(атом АнализДанных
-  @показатель ПроцентПлана
-  @дата       АбсолютнаяМетка
-  @регион     РегионПеречисление
-  @_док       "Анализ данных по регионам с привязкой по времени")
+```yml
+# Внешний API — неизвестная структура
+прц:
+  имя: Пуск
+  эффект:
+    - вход +внеш
+  нач:
+    - Веб запросить "https://api.partner/data"
+    - уст ответ
+
+# Проверка и переход к статике
+макро:
+  имя: ВебЗапрос
+  эффект:
+    - вход +внеш
+  нач:
+    - вставить """
+    + Веб запросить "https://api.partner/data" """
+    - Среда получ ЕслиОтладка
+    - если рез
+    - _ тогда вставить """
+    + уст ответ
+    + СписБайт еслиОк рез
+    + если рез
+    + _ тогда АнализДанных изБайт отчёт,
+    + _      уст отчёт
+    + _ иначе АнализДанных ошНов "ВебЗапрос: " отчёт .ошибка """
+    - _ иначе вставить """
+    + АнализДанных изБайтПринуд отчёт """
 ```
 
 От хаоса внешнего мира → к порядку внутренней системы через безопасные однонаправленные шлюзы.
 
-## 🎯 Заключение: типизация как диалектический процесс
+## 🎯 Заключение: обобщение как диалектический процесс
 
 Предлагаемое решение не устраняет противоречие, а развивает отношения внутренних форм в конкретной ситуации:
 

docs/docs/01_90.md

@@ -19,13 +19,13 @@
 
 Всё остальное — отражение, потенциальность, но не `бытие`.
 
-`Сущее` — это то, что взаимодействует с миром, что занимает место в пространстве-времени, что оказывает воздействие.
+`Сущее` — это то, что взаимодействует с миром, что занимает место в пространстве-времени, что оказывает воздействие (даже если мы не познали сущность).
 
-`Не_сущее` — это отсутствие материи, небытие, ничто.
+`Не_сущее` — это отсутствие материи, небытие, ничто. Ничто нельзя познать не потому что это "вещь в себе", а потому что это "не вещь в нигде".
 
-Но! Диалектика учит: ничто не возникает из ничего, и ничто не исчезает в ничто.
+Но! Диалектика учит: ничто не возникает из ничего, и нечто не исчезает в ничто.
 
-Следовательно, `не_сущее` — то, с чем нельзя взаимодействовать, а момент развития материи вне установленных философских категорий -- есть `нечто`.
+Следовательно, `не_сущее` — то, с чем нельзя взаимодействовать, а момент развития материи вне установленных философских категорий -- есть существующее `нечто`.
 
 ### Противоречие в программировании: null, undefined, None, nil
 
@@ -69,7 +69,7 @@ int len = name.length();
 
 `Option<T>` — шаг вперёд, но не до конца
 
-`None` — всё ещё "значение", хотя и обёрнуто
+`None` — всё ещё "обозначающее значение", хотя и обёрнуто
 
 **Все они** — идеалистические компромиссы:
 
@@ -82,7 +82,7 @@ int len = name.length();
 
 - Только `сущее` может быть значением.
 - Если чего-то нет — оно не может быть передано, не может быть переменной, не может быть в вычислении.
-- `нечто` — не значение, а реально существующее состояние процесса.
+- `нечто` — значение, реально существующее состояние процесса (хотя и непознанное).
 - Оно не существует само по себе, а возникает в практике получения сущего без формы.
 - Переход от `нечто` к `сущему` — через труд, проверку, практику.
 - Как в жизни: хлеб не берётся из воздуха — он выращивается, обрабатывается, доставляется.
@@ -92,37 +92,40 @@ int len = name.length();
 
 ## 📔 Механизм: нечто — особая форма материи, как пространство поиска сущего
 
-Вместо `Option<T>` или `null` — вводим сущность `нечто`, которая является типом, обозначает пространство неопределённости, в котором ещё не решено, есть ли сущее. Но сама содержащая неопределённость сущность `нечто` -- существует всегда.
-
-```prolet
-(// 1. Внешний источник — может не дать сущего,
-если шлюз принимает данные не от prolet-процесса)
-(прц ЗапросИзАпи @вход () нечто
-    (...)
-)
-
-(// Внутри `нечто` — нельзя использовать напрямую,
-		ОШИБКА КОМПИЛЯЦИИ )
-(ОбработатьДанные)
-(уст нечто)
-
-(// Переход к сущему — только через практику)
-(ЕслиНечто нечто как Пользователь
-	(// нечто — теперь сущее)
-	тогда ((Привести нечто к Пользователь))
-	       (Пользователь Обработать))
-        (// нет сущего — альтернатива)
-        иначе (Пользователь ПоУмолчанию))
+Вместо `Option<T>` или `null` — вводим сущность `нечто`, которая является обобщением `СрезБайт`, обозначает пространство неопределённости, в котором ещё не решено, есть ли конкретно сущее. Но сама содержащая неопределённость сущность `нечто` -- существует всегда.
+
+```yml
+# 1. Внешний источник — может не дать сущего,
+#  если шлюз принимает данные не от prolet-процесса
+прц:
+  имя: ЗапросИзАпи
+  эффект:
+    - вход
+  вых:
+    - СрезБайт рез
+  нач:
+    - <...>
+    # Внутри `нечто` — нельзя использовать напрямую,
+    #     ОШИБКА КОМПИЛЯЦИИ
+    - ОбработатьДанные
+    - уст нечто
+    # Переход к сущему — только через практику)
+    - если рез
+    # нечто — теперь непознанное сущее
+    - _ тогда Пользователь изБайтВнеш,
+    - _       Пользователь обработать
+    # нет сущего — альтернатива
+    - _ иначе Пользователь поУмолч
 ```
 
 Ключевые особенности:
 
 - `нечто` — тип для определения пространства возможного,
-- Переменная `нечто` имеет значение до проверки, но имеет тип `срез байт`,
-- После контекста `ЕслиНечто` — в ветке `тогда` переменная становится сущей,
+- Переменная `нечто` имеет значение до проверки, но имеет тип `СрезБайт`,
+- После контекста `если` — в ветке `тогда` переменная становится сущей,
 - В ветке `иначе` — альтернативное действие.
 
-Это — единство бытия и небытия в процессе познания:
+Это — единство познанного и непознанного бытия в процессе познания:
 
 - пока не проверили — нечто, а не сущее,
 - после проверки — сущее возникает как результат практики.
@@ -145,46 +148,69 @@ let s: Option<String> = None;
 
 ### ✔️ Нечто — не значение, а состояние поиска
 
-```prolet
-(прц ИзПорта @вход (...) нечто
-	(...)
-)
+```yml
+прц:
+  имя: ИзПорта
+  эффект:
+    - вход
+  вых:
+    - СрезБайт рез
+  нач:
+    - <...>
 ```
 
 В `prolet` нельзя написать:
 
-```lisp
-()(уст дыра @изм) (// ОШИБКА: "ничего" не есть, контекст отрицания нельзя использовать вообще)
+```yml
+прц:
+  имя: ИзПорта
+  эффект:
+    - вход
+  вых:
+    - СрезБайт рез
+  нач:
+    # Отрицание результата
+    - .
+    # ОШИБКА: "ничего" не есть, контекст отрицания нельзя использовать
+    - уст дыра
 ```
 
 Потому *что ничего не есть*.
 
-## Практическая реализация: три формы работы с *не_сущим*
+## Практическая реализация: три формы работы с *нечто*
 
 ### Форма 1: Проверка (познание через практику)
 
-```prolet
-(НайтиПоНомеру 123 125)(уст нечто)
-
-(ЕслиНечто нечто как Пользователь
-    тогда ((Привести нечто к Пользователь)
-           (уст пользователь)
-           (напечатать "Здравствуй, " пользователь.имя))
-    иначе (напечатать "Пользователь не найден"))
+```yml
+нач:
+  - НайтиПоНомеру 123 125
+  - уст нечто
+  - СрезБайт еслиОк
+  - если рез
+  - _ тогда Пользователь изБайтВнеш,
+  - _       уст пользователь,
+  - _       напечатать "Здравствуй, " пользователь .имя
+  - _ иначе Печатать "Пользователь не найден"
 ```
 
 Только после проверки — пользователь становится сущим.
 
 ## Форма 2: Принудительное извлечение (с ответственностью)
 
-```lisp
-(фн ПрочитатьФайл @вход () нечто)
-
-(ГарантНечто нечто как Пользователь
-    @_док "данные обязательны, иначе сбой конфигурации"
-    иначе ((Пользователь Новый)
-           (уст пользователь))
-)
+```yml
+фн:
+  имя: ПрочитатьФайл
+  эффект:
+    - вход
+  парам:
+    - СписБайт нечто
+  док: "данные обязательны, иначе сбой конфигурации"
+  вых:
+    - Пользователь рез
+  нач:
+    - Пользователь изБайтГарант нечто
+    - _ иначе Пользователь новУмолч
+    - .. рез
 ```
 
 Гарантировать — не отрицание онтологии, а утверждение сущего на основе практики.
@@ -193,8 +219,8 @@ let s: Option<String> = None;
 
 ## Педагогический и психологический аспект
 
-- Новичок не может использовать `нечто` без `ЕслиНечто`.
-- `ГарантНечто` вернёт сущее.
+- Новичок не может использовать `нечто` без `если`.
+- `<...>Гарант` вернёт сущее, либо выполнит обязательное альтернативное действие.
 
 **IDE** подсвечивает:
 

docs/docs/02_10.md

@@ -1,17 +1,17 @@
-# pro.02_10 Диалектическая онтология типов
+# pro.02_10 Диалектическая онтология обобщений
 
-Диалектическая онтология типов подчиняется тем же законам, что и весь диалектический материализм.
+Диалектическая онтология обобщений подчиняется тем же законам, что и весь диалектический материализм.
 
 - От отрицания простого, к снятию противоречия в виде сложного.
 - От базового, к обобщённому.
 
-## Диалектическая онтология типов как отражение структуры объективной реальности.
+## Диалектическая онтология обобщений как отражение структуры объективной реальности
 
 Мы уже отвергли идеалистические перекосы:
 
 - `nil` как "сущее небытие",
 - динамика как хаос,
-- синтаксис как идеалистическая бюрократия.
+- синтаксис (или его отсутствие) как идеалистическая бюрократия.
 
 Но теперь настал момент синтеза:
 
@@ -20,21 +20,21 @@
 
 к диалектической онтологии типа.
 
-## Диалектический путь развития понятия "тип"
+## Диалектический путь развития понятия "обобщение"
 
 ### Простое (метафизика)
 
-Базовый тип — ярлык, классификация. Неподвижен.
+Базовый тип — ярлык, классификация. Неподвижен. Тип понимается, не как абстракция, а как качественный признак присущий множеству сущего, как субстрат.
 
 В терминах `prolet` базовый тип называется *кварк*. Кварки встроены в `prolet` и являются инвариантами информационной материи. Кварки нельзя ни отменить, не переопределить.
 
-`действие`, `бул`, `байт`, `целое`, `вещ`, `строка`
+`действие`, `Бул`, `Байт`, `Цел`, `Вещ`, `Стр`
 
 > 💡 Противоречие: кварки не отражают в полной мере структурную сложность мира. Возникает потребность в нуклонах -- протонах и нейтронах, единственная возможность быть для которых -- быть основанными на кварках.
 
 `Яблоко` , `Груша` , `Час`, `СписокРабот`
 
-Кроме того, `целое` — как кварк не просто число, а объект с поведением. Поведение объекта, способы взаимодействия с миром определяются свойствами самого объекта. С другой стороны, те же свойства объекта диалектически накладывают ограничения на тот же объект.
+Кроме того, `Цел` — как кварк не просто число, а объект с поведением. Поведение объекта, способы взаимодействия с миром определяются свойствами самого объекта. С другой стороны, те же свойства объекта диалектически накладывают ограничения на тот же объект.
 
 ### Снятие противоречия (синтез)
 
@@ -45,7 +45,7 @@
 - кварк перестаёт быть самостоятельной сущностью,
 - и становится протоном или нейтроном -- формой существования материи в информационной сфере.
 
-> 💡 `целое` не просто как один из кварков, а как фундаментальный тип реальности.
+> 💡 `Цел` не просто как один из кварков, а как фундаментальный тип реальности.
 
 ## Критика метафизического подхода к типам
 
@@ -70,7 +70,7 @@
 
 > ⚠️ Важное замечание: арифметический знак `+` при подобном сложении будем неадекватным, так как не отражает *диалектический процесс превращения* одного вида материи в другой.
 
-## Диалектическая онтология типа: тип как единство формы, содержания и практики
+## Диалектическая онтология типа: обобщение как единство формы, содержания и практики
 
 Принципы:
 
@@ -96,7 +96,7 @@
 
 ## Путь от базового к обобщённому: три стадии онтологического развития
 
-### Стадия 1: Отрицание абстрактов (антипод метафизике)
+### Стадия 1: Отрицание абстрактных типов (антипод метафизике)
 
 Мы отрицаем существование "абстрактных типов" как таковых. Как свободные кварки отсутствуют в природе, так и:
 
@@ -104,35 +104,38 @@
 
 Нет `string` . Есть `Имя` , `Хэш` , `Запрос` , `Ответ` .
 
-```prolet
-(протон Рубль или Рубля или Рублей (// синонимы типа)
-  (// Абстракция на основе кварка)
-  @_кварк    целое
-
-  (// Допустимый диапазон на базе кварка, как инвариант типа)
-  @_диапазон (0 999_999_999)
-
-  (// Допустимые операции над конкретным типом, как контракт на поведение)
-  @_операции (слож выч)
+```yml
+протон:
+  # синонимы типа
+  имя: Рубль +или Рубля +или Рублей +эксп
+  # Абстракция на основе кварка
+  эффект:
+    - кварк Цел
+  # Допустимый диапазон на базе кварка, как инвариант типа
+  диапазон: 0 999_999_999
+  # Допустимые действия над конкретным типом, как контракт на поведение
+  действие:
+    - слож +эксп
+    - выч  +эксп
 )
 ```
 
 > 💡 Кварк не уничтожен, но содержится на новом уровне — уровне протона/нейтрона как осмысленная категория с политиками общественных отношений.
 
-### Онтологическое уточнение: атрибут `@_кварк целое`
+### Онтологическое уточнение: эффект `кварк`
 
-Атрибут `@_кварк` опирается на кварк `целое`, но по отношению к материалистичному миру является сущим *только в рамках физического дискурса*. Т.е. кварки не ограничиваются типом `целое`. Но этим тип ограничивает часть цифровой материи на его основе. Кварк `целое` обобщается конкретным протоном с известными наложенными ограничениями (политиками).
+Эффект `кварк` опирается на кварк `Цел`, но по отношению к материалистичному миру является сущим *только в рамках физического дискурса*. Т.е. кварки не ограничиваются типом `Цел`. Но этим типом ограничивается часть цифровой материи на его основе. Кварк `Цел` обобщается конкретным протоном с известными наложенными ограничениями (политиками).
 
 Это — *ключевое* уточнение, которое позволяет не отступать от диалектического материализма, но признать относительную самостоятельность цифрового, равно и математического мышления как *специфической формы отражения реальности*.
 
 ### Интерпретация
 
-| ПОНЯТИЕ                      | СТАТУС В ОНТОЛОГИИ PROLET                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| Физический дискурс | Специфическая физическая практика, в которой аксиома (вроде кварка `целое`) обращаются как первичная данность, <br />и результат высшего обобщения физической практики (исследовали камни, яблоки, дни — и выделили первичную форму)                                                                                                                                                                                                                                                            |
-| Языковой дискурс     | Специфическая общественная практика, в которой кварк `целое` приобретает явные множественные формы <br />(число камней, яблок, дней) с общими и частными атрибутами, но контекст задаётся программистом (определяется конкретный тип).                                                                                                                                                                                                                                                        |
-| Аппаратный дискурс | Специфическая вычислительная практика, в которой произвольно смоделированный тип программистом отражается на<br />реально существующую аппаратуру в доступной форме. В ходе изменения формы сущности преходят атрибуты типа, которые <br />фактически становятся ограниченными конкретными операциями в конкретном алгоритме<br />(обратный переход качества в количество). |
-| @_кварк                        | Указание на форму, заимствованную из физического дискурса, но используемую как инструмент для организации сущего                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| ПОНЯТИЕ  | СТАТУС В ОНТОЛОГИИ PROLET  |
+| -------- | -------------------------- |
+| Физический дискурс | Специфическая физическая практика, в которой аксиома (вроде кварка `Цел`) обращаются как первичная данность, и результат предельной физической практики (исследовали камни, яблоки, дни — и выделили первичную форму)      |
+| Языковой дискурс     | Специфическая общественная практика, в которой кварк `Цел` приобретает явные множественные формы (число камней, яблок, дней) с общими и частными полями, но контекст задаётся программистом (определяется конкретный тип).           |
+| Аппаратный дискурс | Специфическая вычислительная практика, в которой произвольно смоделированный тип программистом отражается на реально существующую аппаратуру в доступной форме. В ходе изменения формы сущности преходят поля типа, которые  фактически становятся ограниченными конкретными операциями в конкретном алгоритме (обратный переход качества в количество). |
+| `кварк`        | Указание на форму, заимствованную из физического дискурса, но используемую как инструмент для организации сущего.  |
 
 Это — далеко от платонизма, по сути это признание автономии отражения на разных уровнях бытия.
 
@@ -141,129 +144,155 @@
 ## 📜 Принципы объявления протонов `prolet`
 
 - Протон — только материализованная форма сущего
-- `целое`,  `строка`,  `вещ`,  `бул`, `байт`, `действие` — связанные кварки, получающие отражение на низком уровне в аппаратуру (реальность).
-- `@_кварк` — не наследование, а встраивание формы из дискурса физического аппарата
+- `Цел`,  `Стр`,  `Вещ`,  `Бул`, `Байт`, `Действие` — связанные кварки, получающие отражение на низком уровне в аппаратуру (реальность).
+- `кварк` — не наследование, а встраивание формы из дискурса физического аппарата
 - Протон всегда имеет социальный контекст состояния
-- Без атрибутов, отражающих практику — *нет протона*
-- Определение вида c использованием кварка `(протон Яблоко @_кварк целое ...)`,
-- Протон может быть основан на любом кварке (кроме кварка `действие`), и только одном кварке. Но атрибутов протона может быть по необходимости.
+- Без полей, отражающих практику — *нет протона*
+- Определение вида c использованием кварка `протон: ...`,
+- Протон может быть основан на любом кварке (кроме кварка `Действие`), и только одном кварке. Но полей протона может быть по необходимости.
 
 ## 📜 Принципы объявления нейтронов `prolet`
 
 - Нейтрон — только материализованная форма сущего
-- `действие` — связанный кварк действия, получающие отражение на низком уровне в аппаратуру (реальность).
-- `@_кварк` — встроенный специфичный кварк, заимствование формы из дискурса физического аппарата
+- `действие` — связанный кварки действия, получающие отражение на низком уровне в аппаратуру (реальность).
+- `кварк` — встроенный специфичный кварк, заимствование формы из дискурса физического аппарата
 - Нейтрон всегда имеет социальный контекст действия,
-- Без атрибутов, отражающих практику — *нет нейтрона*
-- Определение нейтрона c использованием кварка `(нейтрон @_кварк действие ...)` — без действия ошибка онтологии, запрещено,
-- Нейтрон может быть основан только на кварке `действие`, и только одном кварке. Но атрибутов нейтрона может быть по необходимости.
+- Без полей, отражающих практику — *нет нейтрона*
+- Определение нейтрона c использованием кварка `нейтрон: ...` — без действия ошибка онтологии, запрещено,
+- Нейтрон может быть основан только на кварке `Действие`, и только одном кварке. Но полей нейтрона может быть по необходимости.
 
 ## Стадия 2: Сложное — как единство противоположностей
 
-Атом — не просто структура с набор свойств, а единство противоречий:
-
-```prolet
-
-(// любой нуклон построен на единственном кварке,
-        но число атрибутов может быть любым)
-(протон Роль или Права
-    @_обязательно
-    @_кварк Перечисление
-    @_выбор_ (Админ Пользователь Гость)
-    @значение Гость (// По умолчанию, можно менять)
-    @_док "Роль пользователя в системе"
-
-(протон ПользовательНомер
-    @_обязательно
-    @_кварк          Целое
-    @_диапазон      (1 999_999_999)
-    @_автоИнкремент
-    @_уникально
-    @_док ( "идентификация пользователя в системе")
-
-(протон Имя или Название
-    @_кварк      Строка
-    @_умолчание "Иван"
-    @_док       "идентификация пользователя в системе")
-
-(// любой атом имеет множество нуклонов и атомов, число атрибутов может быть любым)
-(атом Пользователь
-    @_номер ПользовательНомер
-    @имя  Имя (// Можно менять)
-    @счёт Счёт
-    @роль Роль
-    @если_акт Активность
-)
+Атом — не просто структура с набором полей, а единство противоречий:
+
+```yml
+# любой нуклон построен на единственном кварке,
+#        но число полей может быть любым
+протон:
+  имя: Роль +или Права +эксп
+  эффект:
+    - кварк Байт
+  выбор: Админ Пользователь Гость
+  # По умолчанию, можно менять
+  умолч: Гость
+  док: "Роль пользователя в системе"
+
+протон:
+  имя: ПользовательНомер + эксп
+  эффект:
+    - кварк Цел
+    - автоИнкремент
+    - уникально
+  диапазон: 1 999_999_999
+  док: "идентификация пользователя в системе"
+
+протон:
+  имя: Имя +или Название +эксп
+  эффект:
+    - кварк Стр
+    - изм
+  умолч: "Иван"
+  док: "идентификация пользователя в системе"
+
+# любой атом имеет множество нуклонов и атомов, число полей может быть любым
+атом:
+  имя: Пользователь
+  поля:
+    - ПользовательНомер номер
+    # Следующее поле можно менять по определению
+    - Имя имя
+    - Счёт счёт
+    - Роль роль
+    - Активность если_акт
 ```
 
 Свойство в атоме может ссылаться только на нуклоны или на атом (этот же или другой) — то есть на материализованное сущее (нуклон или атом).
 
-Атом, который содержит другой атом или нуклоны -- могут быть определены позже, но до момента начала семантического анализа.
+Атом, который содержит другой атом или нуклоны -- могут быть определены позже, но до момента начала действий.
 
 Прямая ссылка на кварк вне протона или нейтрона — запрещена.
 
-Все атрибуты в нуклоне, помечены префиксами:
+Все поля в нуклоне, помечены эффектами:
 
-- `@_кварк` -- системный, нельзя изменить
+- `кварк` -- системный, нельзя изменить определение
 
 В приведённом синтаксисе объявления атома достигается единство формы и содержания:
 
-- Разделение "атрибут vs поле" — идеализм, ведущий к ложному противопоставлению "сущности" и "её атрибутов". В предлагаемом подходе всё является свойством. Кварк `целое` *должен* быть отражён на реально существующий носитель -- протон, который *неизбежно* приобретает дополнительные атрибуты (в том числе контракт, как социальная политика).
+- Разделение "атрибут vs поле" — идеализм, ведущий к ложному противопоставлению "сущности" и "её полей". В предлагаемом подходе всё является полем. Кварк `Цел` *должен* быть отражён на реально существующий носитель -- протон, который *неизбежно* приобретает дополнительные поля (в том числе контракт, как социальная политика).
 - В реальности — есть только объект с характеристиками: у человека — имя, возраст, роль, статус, история.
 - Нет "основных данных" и "метаданных" — есть все данные как единое сущее.
 
 ### Философский и практический смысл
 
-|           АСПЕКТ           | ОБЪЯСНЕНИЕ                                                                                                                                                                                                                                                                                                                                                                                                   |
-| :-------------------------------: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-|        Онтология        | Нуклон — не шаблон, а форма сущего в практике.<br />Если в практике номер всегда уникален и присваивается автоматически, то такое значение — часть его бытия, а не внешнее условие.<br />Контекст не может переопределить его кварк. |
-|    Единство формы    | Если ПользовательНомер используется в 10 атомах — не нужно 10 раз писать `@уникально`. Нарушение — на уровне протона или нейтрона, а не контекста.                                                                                                                                                 |
-|     Безопасность     | Система гарантирует уникальность и обязательность на уровне нуклона, а не доверяет нуклону "не забыть".                                                                                                                                                                                                                          |
-| Эволюция практики | Если правило изменится (например, номер перестанет быть авто-инкрементным), —  меняется одно свойство в нуклоне,<br />а не в конкретном контексте.                                                                                                                                                 |
+| АСПЕКТ     | ОБЪЯСНЕНИЕ                             |
+| :--------: | -------------------------------------- |
+| Онтология  | Нуклон — не шаблон, а форма сущего в практике. Если в практике номер всегда уникален и присваивается автоматически, то такое значение — часть его бытия, а не внешнее условие. Контекст не может переопределить его кварк. |
+| Единство формы | Если ПользовательНомер используется в 10 атомах — не нужно 10 раз писать эффект `уникально`. Нарушение — на уровне протона или нейтрона, а не контекста.   |
+| Безопасность | Система гарантирует уникальность и обязательность на уровне нуклона, а не доверяет нуклону "не забыть". |
+| Эволюция практики | Если правило изменится (например, номер перестанет быть авто-инкрементным), —  меняется одно свойство в нуклоне, а не в конкретном контексте.    |
 
 ### Принципы проектирования в prolet
 
-- Протон несёт свои нормы: `@обязательно`, `@уникально`, `@авто-инкремент`, `@умолчание` — определяются в (протон ...)
+- Протон несёт свои нормы: `уникально`, `авто-инкремент`, `умолчание` — определяются в `протон: ...`
 - Атом — композиция нуклонов, а не конфигурация: она не задаёт правила, а использует уже заданные
-- Свойства в атоме — только контекстные: например, `@источник`, `@момент`, `@ответственный`, но не свойства кварков
-- Повторное указание свойств типа в атоме — избыточно и запрещено, но не запрещены свойства самого свойства (свойство атома рассматривается как нуклон на своём уровне)
-- Нуклон — со всеми своими свойствами, законченная форма сущего, пригодная к использованию в любом атоме.
+- Поля в атоме — только контекстные: например, `источник`, `момент`, `ответственный`, но не поля кварков
+- Повторное указание свойств типа в атоме — избыточно и запрещено, но не запрещены поля самого атома (поле атома рассматривается как нуклон на своём уровне)
+- Нуклон — со всеми своими полями, законченная форма сущего, пригодная к использованию в любом атоме.
 
 ## Форма 3: спецификация — тип как отношение
 
-```prolet
-(спец Хранилище
-    @_док "Абстракция работы с хранилищем"
-    (Нов (ИмяФайла имя) Хранилище.Рез)
-  
-    @_док "Создаёт новое именованное хранилище"
-    (ФайлПолуч (ИмяФайла имя) СписБайт.Рез)
-
-    @_док "Читает файл с диска")
-    (ФайлЗаписать (ИмяФайла имя   СпиСписБайт данные) ЕслиОк.Рез @изм)
-
-    @_док "Записывает файл на диск")
-    (Закрыть ()ЕслиОк.Рез)
-)
-
-(Хранилище (
-    (Нов "тест_хран")(уст хран)
-    (ФайлПолуч "test.txt")
-)
+```yml
+спец:
+  имя: Хранилище
+  док: "Абстракция работы с хранилищем"
+  действие:
+    Нов:
+      тип: прц
+      парам:
+        - ИмяФайла имя
+      вых:
+        - ХранилищеРез
+      док: "Создаёт новое именованное хранилище"
+    ФайлПолуч:
+      тип: прц
+      парам:
+        - ИмяФайла имя
+      вых:
+        - СписБайтРез
+      док: "Читает файл с диска")
+    ФайлЗаписать:
+      тип: прц
+      парам:
+        - ИмяФайла имя
+        - СпиСписБайт данные
+      вых:
+        - ЕслиОкРез +изм
+      док: "Записывает файл на диск")
+    Закрыть:
+      тип: прц
+      вых:
+        - ЕслиОкРез
+
+прц:
+  имя: Пуск
+  нач:
+   - Хранилище Нов "тест_хран"
+   - уст хран
+   - хран ФайлПолуч "test.txt"
 ```
 
 Спецификация определяется не сущностью, а связями — как в диалектике.
 
 - спецификация — объявляет форму взаимодействия, а не математическую сигнатуру
 - Каждое действие — глагол, отражающий практику
-- Параметры: `(%Тип %имя %Тип %данные)` — именованные, ссылаются на нуклоны и атомы
-- Возврат: (%Результат %Тип) — атом, отражающий результат практики
+- Параметры: `%Тип %имя` — именованные, ссылаются на нуклоны и атомы
+- Выход: (%Тип %результат ) — атом, отражающий результат практики
 - Возвращаемый результат может отсутствовать
 - Все нуклоны и атомы в спецификации должны так или иначе существовать, кварки запрещены (только на самом низком уровне)
-- @_док и др. свойства — не обязательны для каждого метода и спецификации, но можно потребовать обязательность на уровне проекта или конкретного действия
-- Спецификация не содержит реализации — только действия с параметрами и возвращаемые значения
+- Эффекты `док` и др. блоки — не обязательны для каждого действия и спецификации, но можно потребовать обязательность на уровне проекта или конкретного действия
+- Спецификация не содержит реализации — только действия с параметрами и возвращаемые значения. Кроме того, спецификации могут предлагать какие-то полные или частичные реализации действий.
 
-## Онтологическая иерархия типов
+## Онтологическая иерархия обобщений
 
 > 💡 Это — спираль развития, а не лестница. Каждый новый уровень — не просто добавление, а результат борьбы и единства противоположностей.
 
@@ -271,9 +300,10 @@
 flowchart LR
 subgraph Практика
     direction TB
-    Субъект --> Цели
-    Цели --> Задачи
-    Задачи --> Требования
+    Мир --> Субъект
+    Субъект --> Отражение
+    Отражение --> Цели
+    Цели --> Действия
 end
 
 subgraph prolet
@@ -313,7 +343,7 @@ prolet --> СинтезАппарат
 - Снимает противоречие в универсальной форме,
 - Делает спецификацию не абстрактной сущностью, а категорией бытия, движения и отношения.
 
-Это — не просто система типов, это — модель познания мира:
+Это — не просто система обобщений, это — модель познания мира:
 
 `от чувственного (примитив)` → `к рациональному (сложное)` → `к диалектическому (обобщённое)``.
 

docs/docs/02_20.md

@@ -6,6 +6,7 @@
 flowchart LR
 subgraph Практика
     direction TB
+    Мир --> Субъект
     Субъект --> Цели
     Цели --> Задачи
     Задачи --> Требования
@@ -34,7 +35,7 @@ end
 prolet --> СинтезАппарат
 ```
 
-В данном случае отображается не иерархия типов, а онтологический процесс становления, в соответствии с законами диалектического материализма:
+В данном случае отображается не иерархия абстрактных типов, а онтологический процесс становления, в соответствии с законами диалектического материализма:
 
 - `отрицание` → `противоположность` → `синтез`,
 - `форма` → `содержание` → `единство формы и содержания`.
@@ -45,7 +46,7 @@ prolet --> СинтезАппарат
 
 ### Практика (сущее)
 
-**Что:** существующие общественные отношения, возникающие противоречия в виде целей, определяющих задачи. Задачи ограничены конкретными условиями и требованиями.
+**Что:** существующие общественные отношения в конкретных условиях существования, возникающие противоречия в виде целей, определяющих задачи. Задачи ограничены конкретными условиями и требованиями.
 
 **Статус:** реально существующую практика, пространство противоречий и ограничений.
 
@@ -53,9 +54,9 @@ prolet --> СинтезАппарат
 
 **Противоречие:**  между тем что есть, и тем что должно быть.
 
-### Свойства
+### Эффекты
 
-**Что**: `@_кварк`, `@_диапазон`, `@_обязательно`, `@значение`, `@активен` — характеристики сущего.
+**Что**: `кварк`, `диапазон`, `обязательно`, `изм` — характеристики сущего.
 
 **Происхождение**: сопровождают всё сущее, как внешние ограничения конкретного существования.
 
@@ -63,7 +64,7 @@ prolet --> СинтезАппарат
 
 **Противоречие:** определяются конкретной практикой, могут быть неприменимы к изменившемся материальным условиям, что способно привести к нарушениям логики.
 
-✅ Свойства — не метаданные, а сущее, выделенное из конкретного контекста.
+✅ Эффекты — не метаданные, а сущее, выделенное из конкретного контекста.
 
 ### Спецификация (конкретизация практики)
 
@@ -75,7 +76,7 @@ prolet --> СинтезАппарат
 
 **Противоречие:** цели формируемые субъектом определяют задачи с заданными свойствами, но не отражаются в конкретном коде. Спецификации формализуют задачи и свойства на основе требований и определяют дальнейшее определение атомов.
 
-✅ Определяются через `(спец ...)`.
+✅ Определяются через `спец: ...`.
 
 ### Атом (конкретизация формы)
 
@@ -85,9 +86,9 @@ prolet --> СинтезАппарат
 
 **Роль в диалектике**: «Синтез: не тип, не значение, а форма организации конкретной практики».
 
-✅ Определяются через `(атом ...)`.
+✅ Определяются через `атом: ...`.
 
-**Противоречие:** спецификации не обладают конкретной структурой сущности,только описывают поведение. Атомы позволяют реализовать описанное поведение с специфичной структурой для конкретной сущности.
+**Противоречие:** спецификации не обладают конкретной законченной структурой сущности,только описывают поведение и частично (возможно) реализует его. Атомы позволяют реализовать описанное поведение с специфичной структурой для конкретной сущности.
 
 ### Нуклон (сущее с формой)
 
@@ -101,32 +102,32 @@ prolet --> СинтезАппарат
 
 ✅ Определяются через:
 
-- `(протон ... @_кварк целое)`,
-- `(нейтрон ... @_кварк действие)`.
+- `протон: ...`,
+- `нейтрон: ...`.
 
 ### Кварки (сущее, основа конкретного)
 
-**Что:** `Целое`, `Строка`, `Бул`, `Срез` — отражение основ цифровой материи, отражение аксиом.
+**Что:** `Цел`, `Стр`, `Бул`, `Срез` — отражение основ цифровой материи, отражение аксиом.
 
 **Статус:** аксимоы, которые будут отражены на аппаратные типы в виде одной формы, основа для протонов и нейтронов.
 
-**Роль в диалектике:** отражение на  аппаратное, предоставление аксиом для протонов.
+**Роль в диалектике:** отражение на аппаратное, предоставление аксиом для протонов.
 
 **Противоречие:** нуклон не может непосредственно быть использованным как аппаратный тип, кварк снимает конкретные ограничения на практическую реализацию.
 
 Встроены, не определяются и не переопределяются.
 
-> В **prolet** нельзя использовать напрямую — только через `@_кварк` в составе нуклона.
+> В **prolet** нельзя использовать напрямую — только через эффект `кварк` в составе нуклона.
 
 ### Материальная база (контекст существования практики)
 
 **Что**: `Аппаратура` — новая конкретная форма аппаратуры, среда практической деятельности.
 
-**Статус**: среда конкретной реализации, пространство доступного, отрицание `не_бытия`.
+**Статус**: среда конкретной реализации, пространство доступного, отрицание как `не_бытия`, так и бесконечного количества форм.
 
 **Роль в диалектике**: «Отрицание  абстрактного, идеалистического».
 
-**Противоречие:** кварк, отражённый на возможности аппаратуры, ничего не знает о возможностях аппаратуры. С ходом развития и/или расширения языка — аппаратура наиболее полно реализует возможности языка.
+**Противоречие:** кварк, отражённый на возможности аппаратуры, ничего не знает о возможностях аппаратуры. С ходом развития и/или расширения языка — язык натболее полно реализует возможности аппаратуры.
 
 ## Действия и спецификации
 
@@ -148,6 +149,7 @@ prolet --> СинтезАппарат
 flowchart LR
 subgraph Практика
     direction TB
+    Мир --> Субъект
     Субъект --> Цели
     Цели --> Задачи
     Задачи --> Требования
@@ -178,25 +180,25 @@ prolet --> СинтезАппарат
 
 ## 📜 Онтологическое содержание уровней
 
-- Свойства: `@_кварк`, `@активен` (Ограничения практики),
+- Эффекты: `кварк`, `авто-инкремент` (Ограничения практики),
 - Спецификации: `Хранилище`, `Аутентификатор` (Обобщение форм практики),
 - Атомы: `Пользователь`, `Заказ` (Форма конкретизации спецификации),
 - Действия: `ПроверитьАктивность` (Действия над сущим),
-- Протона: `Рубль`, `Роль` (Конкретизация сущего),
+- Протоны: `Рубль`, `Роль` (Конкретизация сущего),
 - Нейтроны: `Добавить`, `Печать` (Конкретизация действий),
-- Кварки: `Целое`, `Строка` — основа бытия, отражение в аппаратные типы,
+- Кварки: `Цел`, `Стр` — основа бытия, отражение в аппаратные типы,
 - Аппаратный тип: новый предельно конкретный минимальный тип.
 
 ## 💡 Философское обоснование
 
 Идеи языка следуют диалектическому материализму:
 
-- Развитие идёт не сверху вниз, а от практики к её обобщению в высшей форме, и далее в новой форме опять к практике.
+- Развитие идёт не сверху вниз, а от практики к её обобщению в высшей форме, и далее от новой формы опять к практике.
 - Спецификация не первична, она — порождение практики, как результат познания мира.
 - Кварк как аксиома -- не обладает всей полнотой конкретных свойств,
 - а нуклон — уже вписан в практику на основе кварка,
 - Атом — синтез в виде группы разнородных протонов и нейтронов.
-- «Не `interface` как божественный замысел, а `спецификация` как инструмент труда, и как обобщение структур — вот путь материалистического программирования».
+- «Не `interface` как божественный замысел, а `спецификация` как инструмент труда, и как обобщение поведения — вот путь материалистического программирования».
 
 ## 🎯 Заключение
 

docs/docs/02_30.md

@@ -2,18 +2,18 @@
 
 Язык, отражающий диалектически реальный мир должен явно в общей форме различать две типа контекстов: процесс и функция.
 
-Первое -- может приводить к разным результатам при одном порядке действий.
+Первое -- может приводить к разным результатам при одном порядке действий, обладает эффектами.
 
 Второе -- имеет всегда одно и то же завершение при одних и тех же входных данных (чистая функция).
 
 Введение чёткого онтологического различия между двумя формами действия в языке **prolet** позволяет добиться следующих диалектических эффектов:
 
-- *процесс* — *форма практики*, зависящая от материи, времени и условий, может давать разные результаты при одинаковых шагах.
-- *функция* — *форма чистого преобразования*, детерминированная, всегда дающая одинаковый результат при одинаковых входах, имеющая статус закона.
+* *процесс* — *форма практики*, зависящая от материи, времени и условий, может давать разные результаты при одинаковых шагах.
+* *функция* — *форма чистого преобразования*, детерминированная, всегда дающая одинаковый результат при одинаковых входах, имеющая статус закона.
 
 Все кварки являются функциями в том смысле, что меняя собственное состояние кварк всегда поддерживает собственные инварианты. В этом смысле цифровая материя `prolet` является чистой функцией как закон.
 
-С другой стороны, все кварки обладают состоянием. Таким образом в кварке объединяются закон и материя, что снимает противоречие `закон`-`материя`.
+С другой стороны, все кварки обладают состоянием. Таким образом в кварке объединяются закон и материя, что снимает противоречие `закон` - `материя` .
 
 > Закон не парит над материей -- он её плоть.
 >
@@ -29,19 +29,19 @@
 
 В коде на языке **prolet** различаются два типа контекстов-действий :
 
-- `(прц ...)` — материальный процесс, зависящий от внешних условий, времени, состояния системы.
-- `(фн ...)` — чистое преобразование, не имеющее побочных эффектов, детерминированное, отвечающее критерию математической функции.
+* `прц: ...` — материальный процесс, зависящий от внешних условий, времени, состояния системы.
+* `фн: ...` — чистое преобразование, не имеющее побочных эффектов, детерминированное, отвечающее критерию математической функции.
 
 ## 🔁 Диалектическое различие
 
-| КАТЕГОРИЯ                         | ПРОЦЕСС                                                              | ФУНКЦИЯ                                                              |
-| ------------------------------------------ | --------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
-| Природа                             | Материальный, исторически обусловленный | Формальный, логически детерминированный |
-| Зависимость от времени | Да: каждый запуск — новый момент                  | Нет: время не влияет                                        |
-| Побочные эффекты            | Допустимы (запись, отправка, изменение)     | Запрещены                                                          |
-| Детерминированность     | Нет: может зависеть от входов, состояния   | Да: одинаковые входы → одинаковые выходы  |
-| Онтологический статус  | Практика, действие, изменение                      | Закон преобразования                                     |
-| Аналог в реальности       | Работа завода, регистрация пользователя  | Формула: f(x) = x²                                                  |
+| КАТЕГОРИЯ   | ПРОЦЕСС   | ФУНКЦИЯ    |
+| ----------- | --------- | ---------- |
+| Природа | Материальный, исторически обусловленный | Формальный, логически детерминированный |
+| Зависимость от времени | Да: каждый запуск — новый момент      | Нет: время не влияет       |
+| Побочные эффекты | Допустимы (запись, отправка, изменение)     | Запрещены  |
+| Детерминированность | Нет: может зависеть от входов, состояния | Да: одинаковые входы → одинаковые выходы  |
+| Онтологический статус  | Практика, действие, изменение        | Закон преобразования  |
+| Аналог в реальности | Работа завода, регистрация пользователя | Формула: f(x) = x² |
 
 ```text
 💡 Процесс — это диалектика материи в движении.
@@ -50,31 +50,35 @@
 
 ## ✅ Форма объявления: процесс
 
-```prolet
-(прц ОтправитьУведомление
-        (Пользователь пользователь @изм
-         Сообщение    сообщение          ) Результат КодОшибки @изм(
-    (если (ПроверитьАктивность пользователь)
-     тогда ((ПодготовитьСообщение сообщение)
-            (ПолучитьПочту пользователь)
-            (ОтправитьЧерезПочту @рез)
-            (ЗаписатьЖурнал "Уведомление отправлено"))
-    ))
-)
+```yml
+прц:
+  имя: ОтправитьУведомление
+  парам:
+    - Пользователь пользователь +изм
+    - Сообщение    сообщение
+  вых:
+    - КодОшибки рез +изм
+  нач:
+    - Пользователь еслиАктивен пользователь
+    - если рез
+    - _ тогда Сообщение подготовить сообщение,
+    - _       ПолучитьПочту пользователь,
+    - _       ОтправитьЧерезПочту рез,
+    - _       ЗаписатьЖурнал "Уведомление отправлено"
 ```
 
 ### Семантика процесса
 
-Может возвращать разные результаты при одинаковых `пользователь` и `сообщение`:
+Может возвращать разные результаты при одинаковых `пользователь` и `сообщение` :
 
-- почта упала,
-- email изменился,
-- пользователь деактивирован.
+* почта упала,
+* email изменился,
+* пользователь деактивирован.
 
-Имеет побочные эффекты:
+Имеет побочные эффект:
 
-- запись в журнал,
-- отправка.
+* запись в журнал,
+* отправка.
 
 Зависит от времени и состояния системы. Параметры по умолчанию фиксированы, чтобы явно указать факт изменяемости, нужно передавать атрибут `@изм` .
 
@@ -84,24 +88,40 @@
 
 ## ✅ Форма объявления: функция
 
-```prolet
-(фн ПолучитьКвадрат (Число x) Число(
-    (Умножить x x))
-)
-
-(фн ФорматироватьИмя
-        (Имя имя    Фамилия фамилия) Текст(
-    (Соединить фамилия " " имя))
+```yml
+фн:
+  имя: ПолучитьКвадрат
+  парам:
+    - Число x
+  вых:
+    - Число рез
+  нач:
+    - Число Удвоить x x
+    - .. рез
+
+фн:
+  имя: ФорматироватьИмя
+  парам:
+    - Имя имя
+    - Фамилия фамилия
+  вых:
+    - Текст рез
+  нач:
+    - Имя вТекст имя
+    - уст имя1
+    - Фамилия вТекст фамилия
+    - Текст Доб рез " " имя1
+    - .. рез
 )
 ```
 
 ### Семантика функции
 
-- При одинаковых `x` всегда вернёт одинаковый результат;
-- Нет побочных эффектов: не пишет, не отправляет, не изменяет;
-- Не зависит от времени, состояния, внешних условий;
-- Может быть вычислена в любой момент, *даже заранее*;
-- Поскольку все параметры неизменяемы — нет смысла  указывать *@изм*, в любом случае все параметры воспринимаются как фиксированные.
+* При одинаковых `x` всегда вернёт одинаковый результат;
+* Нет побочных эффектов: не пишет, не отправляет, не изменяет;
+* Не зависит от времени, состояния, внешних условий;
+* Может быть вычислена в любой момент, *даже заранее*;
+* Поскольку все параметры неизменяемы — нет смысла  указывать эффект *изм*, в любом случае все параметры воспринимаются как фиксированные.
 
 ```text
 💡 Функция — чистое преобразование, заимствованное из логического дискурса, но вписанное в практику как инструмент.
@@ -109,58 +129,62 @@
 
 ## 📜 Онтологические правила `prolet`
 
-| ПРАВИЛО | ФОРМУЛИРОВКА                                                                                                                                   |
-| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| 1              | процесс -- действие, зависящее от материи и времени, может давать разные результаты    |
-| 2              | функция -- чистое преобразование, всегда одинаковый результат при одинаковых входах |
-| 3              | функция не может вызывать процесс (иначе — не чистая)                                                           |
-| 4              | процесс может использовать функцию (как инструмент преобразования)                               |
-| 5              | функция не имеет побочных эффектов                                                                                           |
-| 6              | процесс может иметь побочные эффекты (запись, отправка, изменение)                                  |
-| 7              | функция может быть встроена в процесс, но не наоборот                                                          |
+| ПРАВИЛО | ФОРМУЛИРОВКА                       |
+| --------| ----------------------------------- |
+| 1       | процесс -- действие, зависящее от материи и времени, может давать разные результаты    |
+| 2       | функция -- чистое преобразование, всегда одинаковый результат при одинаковых входах |
+| 3       | функция не может вызывать процесс (иначе — не чистая)   |
+| 4       | процесс может использовать функцию (как инструмент преобразования)  |
+| 5       | функция не имеет побочных эффектов                       |
+| 6       | процесс может иметь побочные эффекты (запись, отправка, изменение)      |
+| 7       | функция может быть встроена в процесс, но не наоборот     |
+| 8       | Процесс запрещающий эффект не может вызывать процессы с таким эффектом |
 
 ## 🔄 Пример: процесс, использующий функцию
 
-```prolet
-(прц ОбновитьПрофиль (
-        Пользователь пользователь @изм
-        Имя имя_новое
-        Фамилия фамилия_новая): Результат(
-    (если (ПроверитьПрава пользователь)
-    тогда (
-        (ФорматироватьИмя имя_новое фамилия_новая)
-        (уст полное_имя)
-        (Пользователь.УстИмя (пользователь полное_имя)
-        (СохранитьБаза (пользователь))
-    ))
-)
+```yml
+прц:
+  имя: ОбновитьПрофиль
+  парам:
+    - Пользователь пользователь +изм
+    - Имя имяНов
+    - Фамилия фамилияНов
+  вых:
+    -  Результат
+  нач:
+    - Пользователь праваПровер пользователь
+    - если рез
+    - _ тогда ФорматироватьИмя имяНов фамилияНов,
+    - _       уст полное_имя,
+    - _       Пользователь устИмя пользователь полное_имя,
+    - _       СохранитьБаза пользователь
 ```
 
 Здесь:
 
-- ФорматироватьИмя — функция, чистая, детерминированная;
-- СохранитьБаза — процесс, зависит от прав, состояния базы, времени.
+* ФорматироватьИмя — функция, чистая, детерминированная;
+* СохранитьБаза — процесс, зависит от прав, состояния базы, времени.
 
 ## 💡 Философское обоснование
 
 Нотация следует духу диалектического материализма:
 
-- Материя первична — процесс отражает её движение;
-- Форма вторична — функция есть закон, выделенный из практики;
-- Но форма может служить практике — функция используется внутри процесса;
-- Но не наоборот — практика не может быть сведена к форме.
+* Материя первична — процесс отражает её движение;
+* Форма вторична — функция есть закон, выделенный из практики;
+* Но форма может служить практике — функция используется внутри процесса;
+* Но не наоборот — практика не может быть сведена к одной лишь форме.
 
 ## 💬 Функция — как формула в голове инженера
 
-- Процесс — как работа завода,
-- Формула помогает управлять заводом,
-- но завод не сводится к формуле, с помощью процессов завод преобразует материю в новые формы.
+* Процесс — как работа завода,
+* Формула помогает управлять заводом,
+* но завод не сводится к формуле, с помощью процессов завод преобразует материю в новые формы.
 
 ## 🏁 Заключение
 
 В этой части установлено ключевое онтологическое различие:
 
-- функция — закон преобразования, выделенный из практики, но не зависящий от неё,
-- процесс — реализация практики, зависящая от материи, времени, случайностей.
+* функция — закон преобразования, выделенный из практики, но не зависящий от неё,
+* процесс — реализация практики, зависящая от материи, времени, случайностей.
 
 > 💡 `prolet` больше не смешивает форму и содержание. Он разделяет их — чтобы соединить на высшем уровне.

docs/docs/02_32.md

@@ -2,9 +2,9 @@
 
 _Черновик_
 
-Если смотреть на поток обработки контекстов, хоть они и могут быть записаны в множество строк -- фактически эти разрывы строк введены для облегчения визуального восприятия. Положение записи контекстов в пространстве -- несущественно.
+Если смотреть на поток обработки контекстов, они могут быть записаны в множество блоков -- фактически эти блоки введены для принудительного облегчения визуального восприятия. Положение записи контекстов в пространстве -- существенно.
 
-Семантически все контексты внутри родительского контекста исполняются всё-равно слева направо (и связывание значения и имени в соответствии со стрелой времени всегда слева направо). Т.е. поток исполнения контекста -- это время отражённое на пространство, и оно всегда необратимо. Одновременно, контексты включают в себя иерархию сверху вниз. И это буквально отражение пространственной иерархии.
+Семантически все блоки внутри родительского контекста исполняются всё-равно слева направо (и связывание значения и имени в соответствии со стрелой времени всегда слева направо). Т.е. поток исполнения контекста -- это время отражённое на пространство, и оно всегда необратимо. Одновременно, контексты включают в себя иерархию сверху вниз. И это буквально отражение пространственной иерархии.
 
 Такое осмысление положения контекстов во времени преодолевает разделение между «императивным» (временны́м) и «структурным» (пространственным), создавая **пространственно-временной континуум кода** — буквально как в теории относительности, но материализованный.
 
@@ -12,18 +12,17 @@ _Черновик_
 Контекст «уст» — это не оператор, а **термодинамический акт**:
 
 - Левая часть (причина, potential) имеет бóльшую энтропийную «напряжённость» (готовность к превращению);
-- Правая часть (следствие, actual) — результат потери энергии (использование `@мут` на преобразование);
+- Правая часть (следствие, actual) — результат потери энергии (использование эффекта `изм` на преобразование);
 
 Это отражает реальную направленность потока времени: нельзя «откатить» выполнение процедуры без затрат энергии (вычислительных ресурсов) на «восстановление начального состояния» (откат — тоже работа, тоже процесс).
 
-
 ## Присваивание как идеализм vs Связывание как материализм
 
 Присваивание («=» в С/Python) — это платоническая тень: имя становится «ярлыком» (label), которым можно помечать любое «значение», как корзину товаров. Здесь имя — идея (слово), оторванное от тела, а «значение» — призрак, который можно копировать бесконечно без затрат энергии. Это номинализм (имя первично, сущность вторична).
 Связывание в вашем языке — это гравитационное притяжение:
-Вы не «кладёте значение в имя», вы создаёте материальное отношение между именем и кварком/атомом.
-Это требует энергии (@мут): установление связи — физический акт (как химическая связь или деформация пространства-времени массой).
-Связь локальна: имя существует только в конкретном контексте-мере (как часы в конкретной системе отсчёта ОТО), не «парит в глобальном пространстве имён».
+Вы не «кладёте значение в имя», вы создаёте материальное отношение между именем и кварком/атомом, что и выравжается блоками `прц`, `фн`, `атом`.
+Это требует энергии (`изм`): установление связи — физический акт (как химическая связь или деформация пространства-времени массой).
+Связь локальна: имя существует только в конкретном контексте-мере (как часы в конкретной системе отсчёта ОТО), не «парит в абсолютном одиночестве».
 
 ===== Вот это -- откровенный косяк =====
 

docs/docs/02_40.md

@@ -2,7 +2,7 @@
 
 В языке программирования **prolet**, связывание основано на стреле времени и онтологической чёткости: связывание — не присвоение в стиле `x = f()`, а процесс перехода от действия к сущему, зафиксированный как направленное преобразование во времени:
 
-`(%контекст)(уст %переменная)`
+`- уст %переменная`
 
 Это — не синтаксический курьёз.
 
@@ -37,7 +37,7 @@
 
 ❗ Даже если система «возвращается» в предыдущее состояние — это не возврат во времени, а новый процесс, имитирующий прошлое.
 
-💬 Форма языка — не статична, а процессуальна. Как материя в движении, так и код в **prolet** — развивается во времени.
+💬 Форма языка — не статична, не императивна, а блочна, снимая проиворечие между декларацией и действием. Как материя в движении, так и код в **prolet** — развивается во времени.
 
 ## ✅ Канонический пример
 
@@ -47,17 +47,21 @@
 
 Нельзя использовать то, чего ещё не было. Синтаксис запрещает ссылки на будущее.
 
-```prolet
-(// Фиксированный результат, изменяемость определяется в
-  сигнатуре вызова, по необходимости можно усилить требования,
-  но не ослабить; можно ослабить выход, но не усилить. По Бертрану Мейеру)
-(ПолучитьДанные)(уст данные)
-(ГруппироватьПо данные ключ)(уст группа)
-(СуммироватьПо данные группа)(уст результат)
+```yml
+# Фиксированный результат, изменяемость определяется в
+#   сигнатуре вызова, по необходимости можно усилить требования,
+#   но не ослабить; можно ослабить выход, но не усилить. По Бертрану Мейеру
+нач:
+  - ПолучитьДанные
+  - уст данные
+  - ГруппироватьПо данные ключ
+  - уст группа
+  - СуммироватьПо данные группа
+  - .. рез
 ```
 
 > 💡 Нет «выражений, вычисляемых в параллель без указания порядка».
-> Порядок — не подразумевается, а фиксируется. Параллельность допустима только в разных частях пространства.
+> Порядок — не подразумевается, а фиксируется. Параллельность допустима только в разных частях пространства (в изолятах).
 
 Разберём досконально.
 
@@ -65,30 +69,43 @@
 
 Форма:
 
-```prolet
-(%выражение)(уст %имя)
+```yml
+нач:
+  - %выражение
+  - уст %имя
 ```
 
 или
 
-```prolet
-(// Если возвращает @изм -- можно усилить требования,
-    но не ослабить)
-(Выражение)(уст имя @фикс)
+```yml
+# Если возвращает изм -- можно усилить требования,
+#    но не ослабить
+прц:
+  имя: Пуск
+  вых:
+    - Цел рез
+  нач:
+    # Выражение возвращает изменяемый результат
+    - Выражение
+    # Но возвращён будет неизменямый, так как именно так описан результат
+    - Выражение фикс
+    - .. рез
 ```
 
-#### Внешние скобки — единое выражение связывания
+#### Блок — единое выражение связывания декларации и действия
 
-```prolet
-( ... )
+```yml
+прц:
+  <...>
 ```
 
 ✅ Всё — одно выражение, отражающее процесс становления.
 
 #### Внутреннее выражение — действие, порождающее сущее
 
-```prolet
-(ПолучитьДанные)
+```yml
+нач:
+ - ПолучитьДанные
 ```
 
 Это — вызов, процесс, действие во времени.
@@ -100,7 +117,7 @@
 Указывает направление:
 
 - от процесса к результату,
-- от сущего к именованному.
+- от результата к именованному сущему.
 
 ✅ Допустимо, потому что:
 
@@ -108,10 +125,11 @@
 - отражает направленность времени,
 - не перегружено смыслами.
 
-### фикс / мут — онтологический статус переменной
+### изм — онтологический статус переменной
 
 - `Переменная` — исторический факт, неизменяемый после присвоения
-- `Переменная @изм` — рабочая величина, допускающее последующие изменения
+- `изм` — рабочая величина, допускающее последующие изменения
+- По умолчания переменная является неизменяемой
 
 > 💡 Это — *не тип*, а *статус существования во времени*.
 
@@ -123,49 +141,64 @@
 
 ## ✅ Полная семантика
 
-```prolet
-(ПолучитьДанные)(уст данные)
-(// Результат процесса 'ПолучитьДанные' становится именованным 'данные',
-    и далее считается завершённым, неизменяемым фактом)
-
-(СуммироватьПо данные группа)(уст результат @изм)
-(// Результат процесса 'СуммироватьПо' становится именованным 'результат',
-   но может быть изменён в будущем, если сущее также является @изм)
+```yml
+прц:
+  имя: Пуск
+  парам:
+    - СписЦел группа
+  вых:
+    - Цел +изм
+  нач:
+    - ПолучитьДанные
+    - уст данные
+    # Результат процесса 'ПолучитьДанные' становится 'рез',
+    #     и далее считается завершённым, неизменяемым фактом
+    - СуммироватьПо группа
+    # В качестве аргумента метода изФикс по умолчанию передеётся 'рез'
+    # Результат процесса 'СуммироватьПо' становится именованным 'рез',
+    # но может быть изменён в будущем, если сущее также является "изм"
+    - Цел изФикс
+    # Оператор '..' возвращает результат родителю вызова
+    - .. рез
 ```
 
 ## 📜 Онтологические правила связывания в **prolet**
 
 - Связывание — выражение в парных скобках
-- Форма: `(выражение)(уст имя @изм)` или `(выражение)(уст имя)` без изменяемости
-- `@фикс` — создаёт факт
-- `@изм` — создаёт изменяемую величину
+- Форма: `уст имя` без изменения декларации выхода
+- `+изм` — создаёт эффект изменяемой величины, если не указан -- неизменяемый факт
 - `уст` — стрела времени, отражает переход от действия к сущему
 - Нет форм `:=`, `=`, `<-`, `->` . Только `уст` как отражение реального потока времени в одну сторону
 - Нельзя использовать имя до его присвоения
-- `@фикс` нельзя изменить;
-- `@изм` — можно, если сигнатура вызова определяет изменяемость результата.
+- `изм` — можно, если сигнатура вызова определяет изменяемость результата.
 
 ## 🔄 Пример: полный процесс
 
-```prolet
-(прц ОбработатьДанные () РезультатОк @фикс(
-    (ПолучитьДанные)(уст данные @фикс)
-    (если (ПроверитьДанные данные)
-        тогда (вернуть РезультатОшибка "нет_данных"))
-
-    (ГруппироватьПо данные ключ)(уст группа @фикс)
-    (СуммироватьПо группа)(уст результат)
-
-    (ДобавитьМетаданные результат)(уст результат)
-
-    (вернуть РезультатОк результат)
-    )
-)
+```yml
+прц:
+    имя: ОбработатьДанные
+    вых:
+      - РезОк рез
+    нач:
+      - ПолучитьДанные
+      - уст данные
+      # Последний аргумент -- 'рез', передан неявно
+      - Данные еслиОшибка
+      - если рез
+      - _ тогда РезОшибка "нет_данных",
+      - _      .. рез
+      - ГруппироватьПо данные ключ
+      - уст группа
+      - СуммироватьПо группа
+      # В данном случае неявная переменная 'рез' передаётся явно
+      - ДобавитьМетаданные
+      - .. рез
 ```
 
 - ✅ Каждое связывание — этап фиксации сущего.
-- ✅ `@фикс` — для завершённых фактов.
-- ✅ `@изм` — для рабочих величин, допускающих развитие.
+- ✅ По умолчанию — для завершённых фактов.
+- ✅ `изм` — для рабочих величин, допускающих развитие.
+- ✅ `изм` (рабочая величина) может стать только завершённым фактом.
 
 ## 💡 Философское обоснование
 
@@ -190,9 +223,9 @@
 - Он воспроизводит его в синтаксисе.
 - Стрела времени — не метафора. Она — структура языка.
 
-`(действие)(уст имя @фикс)` — это не присваивание, это — акт фиксации сущего во времени.
+`уст имя` — это не присваивание, это — акт фиксации сущего во времени.
 
-Нет места для `x = f()`. Есть только `(f)(уст x)` — как протокол становления.
+Нет места для `x = f()`. Есть только `уст x` — как протокол становления.
 
 - Время — объективная форма существования материи.
 - Никакого «вневременного» существования типов, функций, значений.

plt/ast_code/соцсеть.yaml

@@ -0,0 +1,49 @@
+имя: СоциальнаяСеть
+версия: prolet-0.1
+язык_по_умолчанию: ru
+список_локалей:
+  - ru
+  - en
+
+протоны:
+  ИмяПользователя:
+    кварк_тип: Строка
+    значение: "Гость"
+    если_мут: true
+    методы:
+      Очистить:
+        если_мут: true
+        если_экспорт: true
+
+  ВозрастПользователя:
+    кварк_тип: Целое
+    значение: "0"
+    если_мут: true
+
+атомы:
+  Пользователь:
+    протоны:
+      имя: ИмяПользователя
+      возраст: ВозрастПользователя
+    нейтроны:
+      Активировать:
+        аргументы:
+          - имя: причина
+            тип: Строка
+            если_литерал: true
+            литерал: "по_умолчанию"
+        если_мут: true
+        если_экспорт: true
+    владелец: локальный
+    если_экспорт: true
+
+прц:
+  Инит:
+    контекст: Пользователь
+    метод: Активировать
+    аргументы:
+      - имя: причина
+        тип: Строка
+        если_литерал: true
+        литерал: "запуск_системы"
+    если_экспорт: true

plt/main.plt

@@ -1,6 +1,48 @@
+# Комментарий. О встречи с # и до конца строки.
+	Ближайший отступ добавляет многострочный комментарий в ранее следующий
+	коментарий.
+	После этого уже не важно, сколько вложенных однострочных комментариев будет предолжено.
+
+	Пустые строки игнорируются и весь текст относится к первому однострочному комментарию.
+	Табы при этом из общего комментария удаляются.
+
+конт:
+	имя: яблоки
+	док: Контекст содержит описание сущности яблоко со всеми необходимыми продедурами
+		и функциями. Яблоко основана на базе цел.
+
+сущ:
+	имя: Яблоко
+	эксп: да
+	база: цел
+	инв:
+		>= 0
+	док: Яблоко выраженное в единицах (цел)
+
+фн:
+	имя: слож
+	эксп: да
+	вх:
+		ябл1: Яблоко
+		ябл2: Яблоко
+	вых:
+		рез: Яблоко # Результат процесса всегда один, но может быть структурой.
+	нач: # Начало чистой функции
+		+ ябл1 ябл2
+		вернуть рез
+
+проц:
+	имя: СвежЗабрать
+
+
+
+(// Пример работы на уровне кварков )
 ()
-(цел нов 10 а)
-(цел нов 20 б)
-(цел слож а б)
-(цел рез в)
-(печать в)
+(Цел Нов 10)
+(уст а)
+(Цел Нов 20)
+(уст б)
+(Цел Слож а б)
+(Цел рез)
+(уст в)
+(Печать в)