SVI Возвращение назад документации (нуедобно в NextCloud)

README.md

@@ -2,7 +2,8 @@
 
 Язык программирования в духе диалектического материализма
 
-[[Основная ссылка]](https://cloudp78su.ipnodns.ru/s/oZKJKpodLr797yq)
+[[Временная ссылка]](https://cloudp78su.ipnodns.ru/s/oZKJKpodLr797yq)
+[[Собственная ссылка]](./docs/pro_readme.md)
 
 ## Лицензия
 

docs/docs/!draft.md

@@ -0,0 +1,66 @@
+ollama run deepseek-r1:14b (на 128к окно контекста)
+ollama run ministral-3:14b (на 256к окно контекста)
+ollama run qwen3-vl:8b     (на 256к окно контекста)
+
+# pro-017 Ассемблер prolet
+
+Ассемблер является отдельным контекстом. Он изолирован от всего языка отдельным выделением. Ассемблер позволяет писать программы в базовых командах **ВМ,** на них строятся все остальные возможности языка. Использование ассемблера, вне гарантий языка не рекомендуется.
+
+## Контекст ассемблера
+
+Ассемблер заключается в специальный контекст:
+
+```prolet
+(асм
+	(...)
+)
+```
+
+В **prolet** нет глобального пространства (абсолютного). Каждый набор действий заключён в своём контексте. Каждая операция существует **только в своём контексте**, и только тот контекст, в котором она определена, наделяет её смыслом и полномочиями.
+
+При этом все объекты выступают в двоякой форме: объект, как хранение значения со  всеми свойствами, и объект как контекст набора допустимых действий.
+
+Поэтому, каждый контекст имеет имя, состояние, свойства и допустимые операции на своём уровне. Контекст может обратиться к вложенному контексту для вычислений, и для извлечения объектов после вычислений.
+
+## RISC декодер
+
+Контекст декодера представлен всеми доступными командами ВМ. Типичное использование декодера:
+
+```prolet
+(асм
+	(уст рег.0 5)
+	(уст рег.0 стек)
+)
+```
+
+Контекст декодера специально описывать не нужно — его включает контекст `асм`. Поскольку речь идёт о командах **ВМ** — на уровне контекста декодера нет доступа к свойствам контекста и т.п. Например, нет `@рез` . Но тем не менее ,всё ещё сохраняются свойства, не влияющие на фактическую работу **ВМ**, например `@_док`.
+
+## Передача управления между уровнями
+
+
+Результат вычислений в `асм` **возвращается как последнее значение**, помещённое в **согласованный регистр или стек**,
+— высокоуровневый контекст (`фн`, `прц`) **интерпретирует это значение как** `@рез`, но **сама инструкция** `@рез` **в** `асм` **не существует**.
+
+### Пример
+
+```prolet
+(фн Сложить (Км a Км b): Км(
+	(асм
+		(рег0 уст a)
+		(рег1 уст b)
+		(слож рег0 рег1)(// результат — в рег0)
+		(влож рег0 стек)(// явная передача результата)
+	))
+	(// здесь @рез = значение, автоматически извлечённое из стека)
+)
+```
+
+# Заключение
+
+::: success
+**Ассемблер** `prolet` **— не расширение языка, а его материальное основание.**
+В нём **нет смысла**, есть **действие**.
+В нём **нет свойств**, есть **инструкции**.
+В нём **нет владения**, есть **передача**.
+
+:::

docs/docs/00_10.md

@@ -0,0 +1,190 @@
+# phi-000 Философские основы языка
+
+> Философы лишь различным образом объясняли мир,  
+> но дело заключается в том, чтобы изменить его.
+
+Карл Маркс, «Тезисы о Фейербахе», 1845 г.
+
+## Диалектический материализм, как основа языка
+
+Из всех доступных философских направлений `диалектический материализм` наиболее полно отражает основную идею проектируемого языка. Как известно, любой язык должен моделировать реально существующие материальные сущности и процессы. Либо скрытые процессы, но имеющие вполне материальную основу. Существует ряд сущностей и процессов, которые не имеют прямой реализации в реальном мире (например игры), но такие процессы смоделированные в виде состояний электронных структур всё-равно в некотором смысле существуют.
+
+## Три закона диалектики, как основа проектирования языка
+
+Все три закона диалектики создают целостный базис для моделирования языка.
+
+### Единство и борьба противоположностей
+
+Закон единства и борьбы противоположностей определяет основы форм и содержаний всего сущего. Основными сущностями в языке программирования являются значения и процессы, связывающие значения. Это две ортогональные философские категории наполняют пространство состояний.
+
+### Закон отрицания отрицания
+
+Закон отрицания отрицания определяет формы, которые содержатся в общей содержащей форме. Перетекание одной формы в другую форму определяет то внутреннее превращение, которое с ходом времени приводит к превращению объемлющей формы в своё новое представление. Так например, программный код при рефакторинге отрицает своё предыдущее состояние, через развитие новой качественной формы.
+
+### Закон перехода количества в качество и обратно
+
+Этот закон диалектического материализма определяет переход накопленных количественных характеристик в новое качество. А при утрате качества -- назад в количественное состояние. Язык программирования в рамках диалектического дискурса проявляет такие свойства как, например -- при переводе текста программы из одной формы в другую более низкого уровня с потерей высокоуровневого смысла (стирание типов). При этом количество кода соответствующего уровня растёт, неявно сохраняя в себе качества более высокого уровня.
+
+## Основные диалектические противоречия в языках программирования
+
+Диалектические пары присутствуют в любом языке программирования. Обычно они описаны либо не полно, либо не описаны вообще. Цель настоящего языка программирования явно описать эти диалектические противоречия и решить их в духе диалектического материализма.
+
+::: info
+`Материя первична, сознание вторично`.
+
+:::
+
+Язык программирования является продуктом объективной реальности.
+
+::: info
+`Все процессы и явления имеют материальную основу.`
+
+:::
+
+Модель должна опираться на объективную реальность, а не на абстрактные идеи.
+
+::: info
+`Все находится в постоянном движении, изменении и развитии.`
+
+:::
+
+Состояния не статичны — они трансформируются под действием внутренних и внешних причин.
+
+::: info
+`Развитие происходит через борьбу противоположностей.`
+
+:::
+
+Внутренние противоречия в ходе меняющихся условий — двигатель изменений. Без них — нет развития.
+
+::: info
+`Переход количественных изменений в качественные.`
+
+:::
+
+Накопление мелких изменений ведёт к скачку, к новому качеству.
+
+::: info
+`Отрицание отрицания.`
+
+:::
+
+Развитие идёт не по прямой, а по спирали: старое отрицается, затем отрицается само отрицание — и возникает что-то более высокое.
+
+Язык программирования не рождается из пустоты, не является плодом субъективной фантазии.
+Он возникает как ответ на объективные потребности:
+
+- Развитие аппаратного обеспечения (процессоры, память, параллелизм).
+- Появление новых задач (веб, ИИ, распределённые системы).
+- Опыт существующих языков (их успехи и провалы).
+
+Следовательно, материальной основой является:
+
+- Техническая база (компьютеры, сети),
+- Социальная практика (программирование как труд),
+- Предшествующие формы (языки `C`, `Lisp`, `Python`, `Rust` и др.).
+
+::: success
+Вывод: язык программирования — производное от производительных сил информационной эпохи.
+
+:::
+
+### Противоречия, как двигатель развития языка
+
+В основе разработки любого языка — борьба противоположностей. Без противоречий нет движения, нет прогресса.
+
+Ключевые противоречия:
+
+- Абстракция vs Эффективность (Чем выше абстракция — тем удобнее писать, но ниже контроль над железом; `Python` (высокоуровневый) vs `C` (низкоуровневый) )
+- Безопасность vs Гибкость ( Безопасность требует ограничений, гибкость — свободы. `Rust` (гарантии владения) vs `C++` (управление памятью вручную) )
+- Простота vs Мощность (Простой язык ограничен, мощный — сложен в освоении. `Go` (простота) vs `Haskell` (высокая абстракция))
+- Статическая vs Динамическая типизация (Предсказуемость против адаптивности. `Java` vs `JavaScript`)
+- Централизованное vs Децентрализованное развитие (Комитет vs сообщество. `ECMAScript` (стандарт) vs `Python` (**BDFL**, потом **PEP**)
+
+Эти противоречия неустранимы полностью, но они разрешаются на новом уровне в каждом новом языке.
+
+## Диалектический путь развития: от идеи к практике и обратно
+
+### Этап 1: Отрицание старого (первая стадия отрицания)
+
+Пример: `C` → `Python` → `Go`.
+
+Каждый новый язык отрицает недостатки предыдущего:
+
+- `C`: небезопасное управление памятью → `Python` добавляет ООП, динамическую типизацию, но усложняет контроль.
+- `Python`: медленный, динамический → `Go` предлагает кратно больше безопасности и скорости, но с **GC**.
+
+### Этап 2: Отрицание отрицания (синтез на новом уровне)
+
+`Go` не просто "ещё один Python", он синтезирует
+
+- Достаточно высокую скорость (как компиляции в отличии от `Си`, так и исполнение в отличии от `Python`),
+- Безопасность через статическую типизацию (строже и `Си`, и `Python`),
+- Современный и понятный синтаксис (хорошо читаемый код, устойчив к нарушению структуры в отличии от `Python`),
+- Поддержку параллелизма как неотъемлемое свойство.
+
+Это не возврат к низкоуровневому, а подъём на ступень выше — безопасное системное программирование.
+
+Закон отрицания отрицания в действии: развитие идёт не по кругу, а по спирали прогресса.
+
+## Переход количества в качество
+
+Постепенное накопление улучшений:
+
+- Небольшие расширения синтаксиса (теги-действия, сопоставление с образцом),
+- Улучшения системы типов,
+- Инструменты (форматеры, линтеры),
+- Экосистема библиотек.
+
+В какой-то момент происходит качественный скачок:
+
+::: info
+Язык перестаёт быть "очередным инструментом" и становится платформой для новых форм практики.
+
+:::
+
+Пример:
+
+- `Python` → стал основой для `data science` и машинного обучения.
+- `JavaScript` → из "языка для кнопочек" превратился в полноценную платформу (`Node.js`, `React`, `Deno`).
+
+Количественные улучшения → качественное изменение роли языка в производстве.
+
+## Практика — критерий истины
+
+Диалектический материализм утверждает: не мысли определяют бытие, а наоборот.
+
+Применительно к языку программирования:
+
+Хороший язык не тот, который красиво выглядит в теории, а тот, который:
+
+- Решает реальные задачи,
+- Упрощает труд программиста,
+- Эффективен в производстве,
+- Развивается в условиях практики общественного характера производства (open source, промышленное применение).
+
+Пример:
+
+- `Scala` — мощный, но сложный → ограниченное распространение.
+- `Go` — простой, но эффективный → массовое внедрение в облаках.
+
+Практика показывает, что работает.
+
+## Роль сознания (программисты, как носители труда)
+
+Хотя материя первична, сознание вторично, но активно.
+
+Гениальные разработчики (как Мао говорил о "героях-массах") — `не творят из ничего, но осознают объективные законы и направляют развитие.`
+
+Пример:
+
+- Андрей Александреску (`D`),
+- Гвидо ван Россум (`Python`),
+- Грейдон Хоуф (`Rust`)
+
+Все они не изобретали законы, но воплотили диалектику практики в синтезе.
+Истинный прогресс — когда сознание не отрывается от практики, а руководит ею.
+
+## Заключение
+
+Все языки с точки зрения диалектического материализма можно рассматривать, как идеалистические (такие как `brainfuck` и им подобные), материалистические (такие как `Оберон-7`), а также языки занимающие переходное положение (такие как `Go` или `Rust`). В рамках текущей работы будет предпринята попытка на новом уровне осмысления создать язык программирования с опорой на диалектический материализм на столько, на сколько это возможно в текущих условиях.

docs/docs/00_20.md

@@ -0,0 +1,190 @@
+# phi-001 Отрицание эклектики в построении языка
+
+На сравнении с диалектикой рассмотрим несостоятельность эклектики, как различие между *научным мышлением* и *сбором мнений*, между единством закона и практики и подменой теории компиляцией цитат.
+
+Рассматривать различия будем в ленинском духе, без прикрас.
+
+## 🔥 Диалектика
+
+**Диалектика** — это учение о всеобщей связи и развитии материи, выраженной в законах движения и становления сущего.
+
+✅ Основные черты:
+
+### Всеобщая связь
+
+::: info
+Ничто не существует изолированно.  
+Каждое явление — в отношении к другим.
+
+:::
+
+Пример: в языке программирования **prolet** тип не существует сам по себе — он возникает на базе абстракции, но только в ходе практики.
+
+### Развитие через противоречие
+
+::: info
+Движущая сила прогресса — борьба противоположностей.
+
+:::
+
+Пример:
+
+- `@мут` (изменяемость) ↔ `@фикс` (неизменность)
+- `Процесс` (практика) ↔ `Функция` (форма)
+
+→ их единство и борьба и рождает новый уровень — `структ`, `интерфейс`.
+
+### Переход количества в качество
+
+::: info
+Накопление изменений ведёт к скачку, к новому качеству.
+
+:::
+
+Пример:
+
+- Многократное использование `нечто` → рождение правила: «Только через `ГарантНечто` потенциальное становится сущим».
+
+### Отрицание отрицания
+
+::: info
+Развитие — не круг, а спираль: старое отрицается, затем отрицается само отрицание.
+
+:::
+
+Пример:
+
+- Тезис: "всё — типы" (идеализм)
+- Антитезис: "нет типов, только сущее" (материализм)
+- Синтез: "есть типы как формы сущего" — диалектика.
+
+### Объективность
+
+::: info
+Законы диалектики — не плод воображения, а отражение объективного движения материи.
+
+:::
+
+💬 Диалектика — как компас:
+
+- она не даёт готовых ответов,
+- но указывает направление движения.
+
+## 🧩 Эклектика
+
+**Эклектика** — это механическое смешение идей, взглядов, теорий без внутренней связи, подбор "удобных" положений вне их закономерной взаимосвязи.
+
+## ❌ Основные черты эклектики
+
+### Отсутствие системы
+
+::: info
+Идеи берутся "по вкусу", без учёта их происхождения и противоречий.
+
+:::
+
+Пример:
+
+- Взять ООП из Запада, марксизм из Ленина, функциональное программирование из Хаскелла — и слепить "язык будущего", не решая, как они связаны.
+
+### Подмена развития — подбором
+
+::: info
+Не развитие через противоречие, а выбор "лучшего" из существующего.
+
+:::
+
+Пример:
+
+- "Мне нравится snake_case, поэтому пусть будет в prolet" — без анализа онтологии.
+
+### Игнорирование противоречий
+
+::: info
+Эклектик замазывает разрывы, вместо того чтобы их преодолевать.
+
+:::
+
+Он говорит:
+
+- «Ну и что, что @мут внутри @фикс? Пусть будет — удобно».
+
+### Субъективизм
+
+::: info
+Критерий истины — не практика, а *личное предпочтение*, *мода*, *авторитет*.
+
+:::
+
+### Статичность
+
+::: info
+Эклектика не порождает нового — она *переставляет старое*.
+
+:::
+
+💬 Эклектика — как мешок с барахлом:
+
+- там может быть золото, гвозди и книга Маркса,
+- но между ними — ни связи, ни смысла.
+
+## ⚖️ Противопоставление
+
+| ДИАЛЕКТИКА                    | ЭКЛЕКТИКА                 |
+|-------------------------------|---------------------------|
+| Учение о движении и развитии  | Подбор готовых решений    |
+| Основана на противоречии      | Избегает противоречий     |
+| Требует анализа условий бытия | Опирается на "удобство"   |
+| Объективна                    | Субъективна               |
+| Порождает новое качество      | Перемешивает старое       |
+| Единство формы и содержания   | Разрыв формы и содержания |
+| Язык общественного            | Язык эгоистичного         |
+
+## 💡 Примеры на отсылках
+
+Одно из принятых правил для реализации в языке программирования **prolet**:
+
+> В prolet не будет абстрактных типов вроде int, string.  
+> Будут только типы сущего.
+
+Это правило на основе применения диалектики:
+
+> это разрешение противоречия между идеализмом типов и материализмом практики,  
+> и разрешает его через синтез:
+>
+> «тип — форма сущего, зафиксированная в практике».
+
+Если бы правило было:
+
+> «давайте возьмём:
+>
+> - type из TypeScript,
+> - struct из C,  
+>   -class из Python и смешаем
+
+это была бы эклектика.
+
+## 🏁 Заключение
+
+::: success
+**Диалектика** — оружие революционного мышления.
+
+:::
+
+Она требует труда, дисциплины, борьбы с собственным невежеством.
+
+Эклектика — удобная лень.
+Она позволяет казаться умным, ничего не понимая.
+
+💬 Гегель как-то сказал:
+
+> Диалектика есть „алгоритм“ философии…  
+> Эклектика — это когда человек берёт то одно, то другое,  
+> не видя связи между ними, и делает из этого „философию“.
+
+💬 А. Ф. Лосев писал:
+
+> Диалектика есть подлинный и единственно возможный  
+> философский реализм.
+
+Именно поэтому язык программирования **prolet** — не очередной DSL основанный на авторитете как частном мнении, а язык, отражающий единство материи, времени и практики.

docs/docs/01_10.md

@@ -0,0 +1,40 @@
+# pro-001 prolet -- проект нового языка
+
+В этой части приводятся некоторые рассуждения, о языке с расширенной и углубленной семантической базой.
+
+Цель:
+Создать язык для децентрализованных, безопасных, экологичных и коллективных систем.
+
+## Диалектические задачи
+
+- Разрешение противоречия между производительностью и безопасностью → система физических перемещений и наблюдений (как поведение макро объектов).
+- Синтез функционального и императивного → чистые функции по умолчанию, процессы с контролируемыми побочными эффектами.
+- Поддержка коллективной разработки → встроенные механизмы для open-source, верификации кода, лицензирования, семантического обмена.
+- Экономия ресурсов → компиляция в WASM/WASI, минимальное энергопотребление (экологический аспект).
+- Доступность → простой синтаксис, но мощная типовая система (обучение масс!).
+
+## Название в диалектическом духе
+
+`prolet` можно раскрыть в разных формах
+
+- "Язык трудящихся" (`prolet-lang`)
+- "Язык с отражением материалистического присвоения, перемещения и трансформаций" (`professional-let`)
+- “Весна” в переводе с болгарского
+- “Простонародный“, `proletaruis` с латинского
+
+## Интегральные показатели
+
+Он не будет "лучшим" в абстрактном смысле, но станет лучшим для решения конкретных задач мульти-агентного, открытого, кооперативного, социалистического информационного общества.
+
+## Заключение
+
+::: success
+Разработка языка программирования — это инженерно-конструкторская задача, опирающаяся на социально-технический процесс, подчинённый законам диалектики:
+
+:::
+
+- Материя (аппарат, задачи, опыт) → первична.
+- Противоречия → двигатель.
+- Практика → критерий истины.
+- Сознание (разработчики) → руководит процессом (направляет его), но не создаёт законы.
+- Время необратимо

docs/docs/01_20.md

@@ -0,0 +1,183 @@
+# pro-002 Диалектико-теоретические требования к языку
+
+Необходимость данного раздела продиктована тем, что без глубокого теоретического обоснования практика слепа.  Прежде чем строить язык, необходимо заложить философский фундамент, ибо каждый синтаксис, каждая парадигма, каждый тип — это не просто технический выбор, а выражение мировоззрения.
+
+Философские основания языка программирования: диалектико-материалистический подход.
+
+## Онтология языка
+
+Что такое программа с точки зрения диалектического материализма:
+
+> Программа — это форма организации материи в информационной сфере.
+
+- Она не существует в идеальном мире Платона.
+- Она не порождение чистого разума, оторванного от практики.
+- Она — продукт человеческого труда, направленный на преобразование объективной реальности (аппаратуры, данных, социальных процессов).
+
+> Программа — это материализованная логика, выраженная в коде;  
+> выполняется на машине, которая изменяет реально существующий мир.
+
+Следовательно, `язык программирования` — инструмент труда, подобный молоту для рабочего или плугу для крестьянина.
+
+## Эпистемологический вопрос
+
+Как язык отражает реальность?
+
+Диалектический материализм утверждает: `сознание отражает бытие`.
+
+Применительно к языку:
+
+::: info
+Хороший язык — тот, который наиболее адекватно отражает структуру объективной реальности, в которой работает программа.
+
+:::
+
+Это означает:
+
+- Если реальность параллельна (множество процессов), язык должен поддерживать параллелизм без избыточных или вычурных абстракций.
+- Если реальность состоятельна (серверы, базы данных), язык должен моделировать состояние безопасно и явно.
+- Если реальность ошибочна (падения, сетевые сбои), язык должен встраивать устойчивость как норму, а не как решение `ad hoc`.
+- Язык не должен искажать реальность ради "элегантности" или "чистоты" — это идеализм, враг материализма.
+
+## Противоречие между формой и содержанием
+
+В каждом языке — борьба формы и содержания:
+
+- Хочется иметь красивый, лаконичный код
+- Машина требует чёткости и эффективности
+- Язык должен быть универсальным
+- Но реальность требует специализации
+
+Диалектический синтез: `форма должна служить содержанию, а не доминировать над ним`.
+
+Пример идеалистического перекоса:
+
+::: warn
+Язык, где всё выражается через монады, но никто не может написать HTTP-сервер за 10 минут.
+
+:::
+
+Язык, где синтаксис "чист", но производительность падает в 10 раз. Это как построить прекрасный дворец, который замедляет проход посетителей, потому что эскалатор всегда едет навстречу.
+
+## Язык как производительная сила
+
+В информационной эпохе язык программирования — производительная сила.
+
+- Он увеличивает производительность труда программиста.
+- Он определяет скорость и качество создания программ.
+- Он влияет на распределение ресурсов (энергия, память, время).
+
+Следовательно, разработка языка — с одной стороны акт индивидуального творчества, с другой стороны -- акт коллективной значимости.
+
+Капиталистический подход: язык, который делает программиста зависимым от проприетарных платформ (`Swift`, `C#` в прошлом).
+
+Общественно-коллективный подход: язык, который освобождает труд от частной зависимости, делает его коллективным, доступным, прозрачным (`Python`, `Rust`, `Lua`).
+
+::: info
+Язык должен быть орудием освобождения умственного труда, а не инструментом эксплуатации через зависимость.
+
+:::
+
+## Язык и сознание: формирование "программиста нового типа"
+
+Карл Маркс как-то сказал: *"Условия, которые изменяют людей, — это практика."*
+
+Язык программирования, как инструмент познания мира, изменения мира и воспитания формирует мышление программиста.
+
+- Если язык учит думать в терминах состояния и побочных эффектов — он культивирует хаос.
+- Если язык учит думать в терминах потоков данных, чистоты, композиции — он развивает диалектическое мышление.
+
+::: info
+Язык — это педагогический инструмент.
+
+:::
+
+Новый язык должен:
+
+- Развивать системное мышление,
+- Поощрять коллективную разработку, как преобладающий способ производства на практике
+- Обучать ответственности за код (в том числе — экологической, социальной).
+
+## Философские принципы проектирования языка как постулаты
+
+На основе диалектического материализма следуют шесть фундаментальных принципов:
+
+### Принцип объективности
+
+Синтаксис и семантика языка должны отражать объективные законы информационной материи, а не субъективные предпочтения авторов.
+
+### Принцип противоречия
+
+Язык должен не избегать противоречий, а позволять их осознанно разрешать (например, безопасность vs производительность — через явные аннотации).
+
+### Принцип историчности
+
+Язык должен учитывать объективные обстоятельства каждого момента времени своего существования
+
+### Принцип временной необратимости
+
+Язык должен следовать принципу необратимости вдоль оси времени. Нельзя использовать то:
+
+- чего ещё нет
+- и то, чего уже нет.
+
+### Принцип развития
+
+Язык должен быть открыт для эволюции, но не ради моды, а ради развития производительных сил.
+
+### Принцип практики
+
+Каждая конструкция языка должна проходить проверку практикой, а не "элегантностью".
+
+### Принцип единства теории и практики
+
+Язык должен объединять математическую строгость (теория типов, логика) и практическую применимость (встраиваемость, производительность).
+
+### Принцип коллективизма
+
+Язык должен способствовать совместной разработке, открытости, доступности знаний — быть инструментом не для интеллектуальной элиты, а для широких масс как профессиональных программистов, так и не профессиональных (студенты, исследователи, учёные, энтузиасты).
+
+## Критика идеалистических течений в языках программирования
+
+Чтобы укрепить философский фундамент, необходимо разоблачить идеалистические отклонения:
+
+### Платонизм типов
+
+`"Типы существуют в идеальном мире"`
+
+Типы — инструмент для предотвращения ошибок в реальных системах
+
+### Культ элегантности
+
+`"Код должен быть красив"`
+
+Код должен быть работающим, понятным, безопасным
+
+### Аскетизм (минимализм ради минимализма)
+
+`"Меньше — значит лучше"`
+
+Меньше — если это служит практике, а не догме
+
+### Техноэлитаризм
+
+`"Только избранные поймут этот язык"`
+
+Хороший язык — тот, который доступен массам, но обладает достаточной семантической мощностью для экспертов
+
+Все эти течения — отражение эгоистического индивидуализма в программировании.
+
+Вывод: `язык как орудие революционной смены парадигмы в сознании`
+
+::: success
+Разработка языка программирования — не инженерная утилитарная задача, а акт философский, политический, имеющий глубокое влияние на сам способ существования общества.
+
+:::
+
+Разрабатываемый язык:
+
+- Будет материалистическим — опирается на реальность,
+- Диалектическим — разрешает противоречия,
+- Практическим — служит делу преобразования мира,
+- Коллективистским — строится и используется сообществом.
+- Педагогическим — служит построению нового способа мышления разработчиков.

docs/docs/01_30.md

@@ -0,0 +1,287 @@
+# pro-003 Разрешение диалектических противоречий на новом уровне
+
+После выявления ключевых противоречий в программировании через призму диалектического материализма необходимо завершить акт творчества в виде синтеза новых сущностей и процессов.
+
+> Теория без практики мертва, а диалектический материализм постулирует совмещения теории и практики.
+
+Настал момент синтеза — момент, когда из борьбы противоположностей рождается новое качество, новый язык, отражающий объективные законы развития информационной материи.
+
+Приступим к диалектическому разрешению противоречий в проектировании языка — в духе Маркса, Энгельса, Ленина, но применительно к коду, а не к полю классовой битвы.
+
+## Разрешение противоречий в языке prolet на принципах диалектического материализма
+
+### ⚔️ Противоречие: Абстракция vs Эффективность
+
+Антиподы:
+
+- Абстракция — позволяет мыслить в терминах "что", а не "как", что ускоряет разработку.
+- Эффективность — требует контроля над памятью, регистрами, кэшем. Принуждает мыслить в терминах "как", а не что, что замедляет разработку.
+
+Идеалистический путь:
+
+- Или "всё высокоуровневое, пусть машина сама разбирается" (`Java`, `Python`),
+- Или "только железо, абстракции — для слабаков" (`C`, ассемблер).
+
+Диалектическое разрешение:
+
+`Иерархия абстракций с прозрачным контролем.`
+
+Язык предоставляет высокоуровневые конструкции по умолчанию (например, `List`, `Stream`, `Actor`).
+Но позволяет спускаться к низкоуровневому коду, если это требует практика.
+Переход между уровнями не скрыт, а явен — через ключевое слово низкоуровневый или аннотацию `@система`.
+
+Пример:
+
+```prolet
+(прц ОбработатьДанные (СписокБайт данные @мут): Список.Байт (
+    (// высокоуровневая композиция)
+    (ФильтроватьДанные х по данные
+            (Сравнить х > 10)
+            (ФнКвадрат @рез))
+	)
+)
+```
+
+```prolet
+(// при необходимости — ручное управление)
+(прц КопироватьПамять @система (Сис.Адр источник
+                                Сис.Адр цель
+                                Сис.Размер размер)
+    (асм (ПовторОтДо рег0 рег1))
+)
+```
+
+Философский смысл:
+
+`Единство абстрактного и конкретного`
+
+Сознание не отрывается от материи — программист видит, что происходит с памятью.
+
+::: info
+Развитие идёт от простого к сложному, от конкретного к абстрактному, и обратно к конкретному в высшем виде.
+
+:::
+
+### ⚔️ Противоречие: Безопасность vs Гибкость
+
+Антиподы:
+
+- Безопасность требует ограничений (проверка типов, владение, immutability).
+- Гибкость требует свободы (указатели, рефлексия, изменение поведения в рантайме).
+
+Идеалистический путь:
+
+> "Безопасность любой ценой" — язык становится *тюрьмой* (например, строгие ограничения в некоторых версиях `Ada` или `Rust`).
+
+"Свобода любой ценой" — хаос, утечки, уязвимости, непредсказуемое поведение (`C`, `C++`, `JavaScript`).
+
+Диалектическое разрешение:
+
+`Безопасность по умолчанию, гибкость по необходимости, с явным указанием ответственности программиста.`
+
+По умолчанию:
+
+- Вся память управляется системой существования (как в линейных или афинных типах, но с ориентацией на законы реального мира),
+- Все данные — неизменяемые,
+- Побочные эффекты — явно следуют из кода.
+
+При необходимости — выход из рамок, но:
+
+- только с явным одобрением такого блока,
+- С явным комментарием причины (автоматически включается в документацию),
+- С обязательным тестированием.
+
+```prolet
+(// Функции никогда ничего не изменяют )
+(фн СложитьДист1 (
+        Км a
+        М  b): Км(
+    (СложитьКмМ a b))
+)
+
+( // Процессы могут, но не обязаны иметь побочные эффекты)
+(прц ЗначПоАдр
+        @система
+        @обоснование "взаимодействие с драйвером"
+        (Адр адр @мут): Адр (
+    (ЗначИз адр))
+)
+```
+
+Философский смысл:
+
+> Свобода есть осознанная необходимость (по Гегелю, переосмысленному Марксом).
+
+Гибкость не отменяется, но подчиняется интересам целого — стабильности системы.
+
+::: info
+Это как общественный порядок: каждый член может высказать мнение, но после решения — действует в соответствие с общественным решением и дальнейшие высказывания не имеют влияния на принятое решение до следующего голосования(принцип демократического централизма).
+
+:::
+
+### ⚔️ Противоречие: Простота vs Мощность
+
+Антиподы:
+
+- Простота — доступность, быстрое обучение.
+- Мощность — выразительность, возможность решать сложные задачи.
+
+Идеалистический путь:
+
+- Либо "просто, но беспомощно" (`BASIC`),
+- Либо "мощно, но непонятно" (`APL`, `Perl`).
+
+Диалектическое разрешение:
+
+`Язык растёт вместе с программистом.`
+
+Начальный уровень:
+
+- Минимальный синтаксис,
+- Интерактивная среда,
+- Интегрированная помощь (как **REPL** с подсказками от "Центра обучения").
+
+По мере роста:
+
+- Раскрываются продвинутые возможности: метапрограммирование, unsafe, concurrency.
+- Но только после прохождения проверки знаний (встроенный обучающий модуль).
+
+Это как путь солдата:
+
+- сначала — базовое вооружение,
+- затем — тактические приёмы,
+- затем — стратегическое мышление.
+
+Философский смысл:
+
+- Развитие идёт от простого к сложному, но в единстве с практикой.
+- Язык не принижает новичка и не обожествляет эксперта.
+
+::: info
+Это коллективное восхождение к мастерству, а не культ индивидуального гения или угнетения новеньких.
+
+:::
+
+### ⚔️ Противоречие: Статическая vs Динамическая типизация
+
+Антиподы:
+
+- Статика — безопасность, производительность.
+- Динамика — гибкость, быстрая разработка.
+
+Идеалистический путь:
+
+- "Только статика!" — жёсткость, бюрократия типов.
+- "Только динамика!" — хаос, ошибки в рантайме.
+
+Диалектическое разрешение:
+
+`Гибридная система с постепенной типизацией и выводом.`
+
+Все переменные имеют тип, но он может быть выведен.
+Можно использовать динамический тип, но:
+
+- Только в ограниченных зонах,
+- С предупреждением, (если не подавлено)
+- *Не разрешён* в критических модулях (ядро, безопасность).
+
+Система типов расширяема: Пользователь может определять зависимые типы для критически важных участков.
+
+Пример:
+
+```prolet
+(// тип выведен: Целое;
+    определение @фикс -- если не указано устанавливается по умолчанию)
+(Рубль 42)(уст х)
+
+(// явная динамика — только при необходимости,
+    тип нечто -- определяется на стороне вызова)
+(ПолучитьИзВнешнегоАпи)(уст нечто)
+
+(// но в блоке безопасности — только статика)
+(фн ПроверитьДоступ @строго(
+        Пользователь пользователь
+        Роль         роль        ): ЕслиОк(
+    (// динамические типы запрещены здесь))
+)
+```
+
+Философский смысл:
+
+Единство противоположностей: не выбор между статикой и динамикой, а синтез в зависимости от контекста.
+
+::: info
+Как в экономике: плановая система в ключевых отраслях, рыночные механизмы — в остальных.
+
+:::
+
+### ⚔️ Противоречие: Индивидуализм vs Коллективизм в разработке
+
+Антиподы:
+
+- Индивидуализм — "я написал, я понимаю".
+- Коллективизм — код как достояние коллектива.
+
+Диалектическое разрешение:
+
+`Язык встроен в экосистему коллективного труда.`
+
+Встроенные механизмы:
+
+- @автор, @соавторы, @история\_изменений,
+- Обязательные рецензии перед коммитом (на уровне языка),
+- Автоматическая генерация отчётов о вкладе (для оценки труда).
+- Код-ревью — не опционально, а обязательная фаза компиляции в производство.
+
+Философский смысл:
+
+- Индивидуальное творчество служит коллективу.
+- Нет места "гению в подвале", есть место участнику команды трудящихся умственного труда.
+
+  ::: info
+  Программирование -- практическая форма *общественных* отношений.
+
+  :::
+
+### Общее разрешение: язык как диалектический синтез
+
+- Абстракция vs Эффективность
+- Высокоуровневый vs низкоуровневый
+- Иерархия с прозрачным контролем
+- Безопасность vs Гибкость
+- Ограничения vs свобода
+- Безопасность по умолчанию, гибкость с ответственностью
+- Простота vs Мощность
+- Лёгкость vs сложность
+- Развитие вместе с программистом
+- Статика vs Динамика
+- Предсказуемость vs адаптивность
+- Постепенная типизация с контекстом
+- Индивидуализм vs Коллективизм
+- "Я" vs "Мы"
+
+`Код — достояние коллектива, труд — прозрачен`
+
+::: info
+Синтез не устраняет противоречия — он поднимает их на новый уровень, где они перестают быть разрушительными и становятся движущей силой прогресса.
+
+:::
+
+## Заключение
+
+Язык, как орудие диалектической революции в мышлении:
+
+- Язык не может быть "нейтральным".
+- Каждое его решение — выбор стороны в множестве противоречий между хаосом и порядком, между элитой и массами, между идеализмом и материализмом.
+
+`prolet` — это не просто инструмент.
+
+::: success
+Это — форма сознания нового программиста-труженика, который:
+
+:::
+
+- Мыслит диалектически,
+- Действует материалистически,
+- Работает коллективно,
+- Служит прогрессу.

docs/docs/01_40.md

@@ -0,0 +1,225 @@
+# pro-004 Многоэтажность языка
+
+Рассмотрим варианты реализации противоречия "низкий уровень -- высокий уровень". Как можно синтаксически обозначить такие участки кода? Попробуем применить передовые практики из инженерной психологии с учётом готовности конкретного программиста к переходу с уровня на уровень.
+
+Этот вопрос сочетает в себе не только технический аспект, но и психофизиологический и педагогический: как синтаксически оформить переход между уровнями абстракции с учётом готовности программиста, его когнитивной нагрузки и развития как специалиста?
+
+Вопрос разделителей в коде — перерастает в вопрос организации сознания, вопрос диалектического восхождения от чувственного к рациональному, от простого к сложному.
+
+И здесь необходимо опираться не только на диалектический материализм, но и на передовые достижения инженерной психологии, когнитивной науки и педагогики программирования.
+
+Анализ противоречия: `низкий уровень vs высокий уровень`
+
+Суть противоречия:
+
+- Высокий уровень — близок к человеческому мышлению, безопасен, продуктивен.
+- Низкий уровень — близок к машине, эффективен, но опасен, требует глубоких знаний.
+
+Риск:
+
+- Если не ограничить доступ — новичок сломает систему.
+- Если запретить — эксперт будет сдерживаться.
+
+Задача: создать диалектическую границу, которая:
+
+- Не исчезает (не идеализм),
+- Не непреодолима (не метафизика),
+- Поддерживает развитие (диалектика),
+- Учитывает психологию программиста (гуманизм).
+
+## 📙 Принципы проектирования синтаксиса (на стыке философии и психологии)
+
+### Принцип осознанного перехода
+
+Переход между уровнями — не автоматический, а сознательный акт, требующий понимания последствий.
+
+### Принцип когнитивной видимости
+
+Низкоуровневые участки визуально и семантически выделены, чтобы мозг сразу распознавал повышение риска.
+
+### Принцип постепенного погружения
+
+Переход — не скачок, а лестница, соответствующая зоне ближайшего развития (по Выготскому).
+
+### Принцип обратной связи
+
+Система даёт немедленную обратную связь о сложности и рисках операции.
+
+### Принцип готовности
+
+Доступ к низкоуровневому коду может регулироваться профилем программиста (уровень, опыт, пройденные модули).
+
+## Варианты синтаксической реализации
+
+Вариант 1: Явный блок низкоуровневый с контекстным предупреждением
+
+```prolet
+(прц ОбработатьДанные (Список.Байт вход @мут): Список.Байт (
+    (// Высокий уровень — чисто, безопасно)
+    (ФильтрПо вход
+        (x > 10)
+        ( @рез * 2))
+    )
+)
+
+(// Внимание! Здесь действуют другие законы)
+(прц СкопироватьПамять @система
+        @прог_уровень 3
+        @одобрение_нужно
+        (Байт     источник
+         Байт     цель
+         СбщДлина длина)(
+    (Цикл для i от 0 до длина
+        (// Прямое обращение к памяти)
+        (асм (рег0 загр i))
+    )
+)
+```
+
+Психологические преимущества:
+
+- Свойство `@система` — семантический маркер, активирует режим повышенного внимания.
+- Цвет подсветки — красный или оранжевый (по стандартам UX).
+- IDE показывает подсказку: "Вы вошли в зону повышенного риска. Проверьте указатели, границы массивов."
+
+Диалектический смысл:
+
+- Граница не устранена, но преодолима сознательно.
+- Противоречие разрешено через форму, а не подавление.
+- Компилятор требует внешней проверки (главный человек, а не система).
+
+Вариант 2: Модульный подход с уровнем доступа
+
+```prolet
+(модуль БезопаснаяОбработка (
+    (прц Фильтровать(ДанныеПоток данные @мут ): ДанныеПоток (
+        если (Сравнить данные @длина > 10)
+        тогда (ДобСписок данные))
+    )
+)
+
+(// Только для программистов с уровнем >= 3, старший инженер)
+(модуль НизкоуровневаяОптимизация
+    @мод_уровень 4
+    (импорт
+        Ядро.Память
+        Ядро.Асм)
+
+    (фнКопироватьБыстро @система (...) (...))
+)
+```
+
+Реализация "готовности":
+
+- У программиста есть уровень компетенции (1..5) для реализации и проверки
+- Уровень определяется пройденными учебными модулями (1..3) и опытом (4, 5),
+
+Компилятор блокирует импорт модулей уровня (1..3), если:
+
+- у разработчика уровень < 3.
+- у модуля недостаточный уровень
+
+Можно запросить временный доступ с одобрения старшего программиста.
+
+Психологический эффект:
+
+- Создаёт систему постепенного вхождения, как в боевую подготовку.
+- Формирует ответственность, а не безрассудную смелость.
+- Повышает контроль за опасными средствами.
+
+При этом снимает ответственность с программиста, если его уровень для выполнения соответствующей задачи недостаточен.
+
+Вариант 3: Гибридный синтаксис с "прозрачным спуском"
+
+```prolet
+(прц ОбработатьГруппу @уровень_ниже(
+    (ПолучитьДанные): данные(
+    (// Высокий уровень)
+    (ГруппироватьПо данные @ключ)(уст группа)
+    (СуммироватьПо данные группа)(уст результат)
+
+    (// Спуск в низкий уровень — через ключевое слово и атрибут)
+        (// Теперь можно использовать указатели, asm)
+        (асм
+			(рег0 cохр результат)
+        	(рег0 инк))
+	)
+
+    (// Подъём автоматически))
+)
+```
+
+Особенности:
+
+Атрибут `@уровень_ниже` — синтаксический шлюз, как шлюз в подводной лодке.
+
+- При входе — предупреждение в **IDE**, подсветка фона.
+- Автоматический возврат к безопасному контексту после выхода.
+
+Когнитивная выгода:
+
+- Мозг четко фиксирует границу.
+- Не нужно держать в памяти: "а я всё ещё в @система?".
+- Уменьшает когнитивную нагрузку.
+- На уровне компилятора перехватывает обращение к опасным средствам.
+
+Вариант 4: Интеграция с системой обучения (обучающий компилятор)
+
+```prolet
+(прц ОбработатьПамять @система (Срез.Байт размер)): асм.адр(
+    (// Компилятор замечает:  "Вы используете сырые указатели")
+	если (Сравнить уровень < 3)
+    тогда (ПройтиМодуль "Управление памятью (5 мин)")
+    иначе (ИспользоватьБезопасныйАналог "Буфер.Байт")
+    )
+)
+```
+
+Реализация:
+
+1. Встроенный обучающий агент анализирует код.
+2. При обнаружении низкоуровневых конструкций:
+
+- Показывает подсказку,
+- Предлагает обучающий модуль,
+- Может заблокировать коммит, пока модуль не пройден.
+
+Философский смысл:
+
+- Единство обучения и труда.
+- Программист не просто пишет код — он развивается в процессе.
+- Это — советская школа программирования, доведённая до совершенства.
+
+Рекомендованная модель: синтез вариантов (диалектический выбор)
+
+::: info
+Мы не должны выбирать одно, мы должны синтезировать новые возможности, которые помогают разработчику, а не ставить его в тупик из-за потери контроля над кодом.
+
+:::
+
+Поддержка **IDE**:
+
+- Цветовая зона: зелёная → жёлтая → красная.
+- При наведении: "Вы находитесь в зоне высокой ответственности. Рекомендуется ревью."
+- Автоматическое предложение: "Заменить на безопасный аналог?"
+
+## Заключение
+
+Язык программирования может быть спроектирован:
+
+- как многоуровневый по возможностям
+- как педагогический механизм
+- как дополнительное средство безопасности, встроенное в сам язык
+
+Синтаксис языка — это не абстрактная форма, а содержание практического, деятельного сознания.
+
+Реализация противоречия "низкий/высокий уровень" должна:
+
+- Не устранять границу (иначе — анархия),
+- Не делать её вечной (иначе — бюрократия),
+- Превращать её в лестницу развития.
+
+::: success
+`prolet` не просто средство написания программ, а средство воспитания программиста нового типа — диалектического, ответственного, коллективистского, готового к труду и обороне в цифровую эпоху.
+
+:::

docs/docs/01_50.md

@@ -0,0 +1,306 @@
+# pro-005 Диалектика стиля нотации
+
+Есть ещё одна важная часть в противоречии низкого и высокого уровня. Подход к нотации близкий к реализации в `Си` или `Rust` сейчас наиболее популярен. Но ведь есть и другие устоявшиеся подходы. Например, `Pascal` и `Lisp`. Сравним все три, выберем наиболее диалектичный подход, наиболее экономичный для мыслетоплива программиста, наиболее снижающий вероятность ошибок с точки зрения инженерной психологии, наиболее сужающий семантический контекст перехода между уровнями для программиста в качестве педагогической меры. Также не забудем о таком важном моменте, что диалектический язык -- это язык в движении, гибкий, развивающийся, способный дополнять себя новыми семантическими конструкциями в зависимости от решаемой задачи.
+
+## 📙 Диалектический взгляд на семантику
+
+Вопрос семантики с диалектической глубиной:
+
+- не просто «что есть», а «что становится»,
+- не просто сравнение, а оценка по критериям развития, экономии мыслетоплива и педагогической эффективности.
+
+::: info
+Это не технический выбор между синтаксисами — это борьба форм сознания, отражённая в языках программирования.
+
+:::
+
+## Анализ стилей
+
+Рассмотрим три подхода:
+
+`Pascal` — язык порядка, строгости, централизованного контроля,
+
+`Lisp` — язык свободы, мета-абстракции, бесконечной гибкости,
+
+`Rust` — язык компромисса, безопасности через владение, статической проверки.
+
+И сравним их не по синтаксису, а по философскому содержанию, психологической нагрузке и диалектической зрелости.
+
+### Метафизический идеализм
+
+Философия: `порядок ради порядка`
+
+Отношение к уровню абстракции: `Жёсткая иерархия, переходы запрещены, внешний (eval)`
+
+Экономия мыслетоплива: много boilerplate (как принуждение новичков), принуждает к шаблонам, тормозит квалифицированных специалистов
+
+Семантический контекст перехода: практически отсутствует — нет низкоуровневых операций
+
+Вероятность ошибок: низкая (ограниченность), но не из-за понимания, а из-за цензуры
+
+Гибкость и развитие: низкая (язык заморожен, расширения — через диалекты)
+
+Педагогическая эффективность: высокая (учит дисциплине)
+
+### Платонический идеализм
+
+Философия: `всё — форма, материя не важна`
+
+Отношение к уровню абстракции: `Нет уровней — всё выражается через (macro)`
+
+Экономия мыслетоплива: высокая для экспертов, катастрофически высока для новичков
+
+Семантический контекст перехода: отсутствует полностью — всё «на одном уровне»
+
+Вероятность ошибок: высокая (можно всё, включая саморазрушение)
+
+Гибкость и развитие: очень высокая (язык может породить себя заново)
+
+Педагогическая эффективность: низкая (не принуждает структурировать траекторию обучения)
+
+### Смешанный подход
+
+Философия: `безопасность через практику владения`
+
+Отношение к уровню абстракции: `Чёткая граница: (unsafe) как зона сознательного риска`
+
+Экономия мыслетоплива: сложный вывод типов, но безопасность снижает ошибки (ставит в ступор новичков, психологически давит на профи, вызывает стресс при длительном использовании)
+
+Семантический контекст перехода: с использованием `unsafe` чёткая граница
+
+Вероятность ошибок: низкая (ошибки на этапе компиляции, если нарушено владение; высокая когнитивная нагрузка)
+
+Гибкость и развитие: средняя (макросы, но в рамках системы типов)
+
+Педагогическая эффективность: низкая (высокий порог входа, крутая кривая обучения, не следует принципам научной педагогики)
+
+## Диалектическая оценка каждого подхода
+
+### `Pascal`
+
+Метафизический идеализм в синтаксисе
+
+Суть: мир должен быть упорядочен сверху, иерархически, без противоречий.
+
+Подход: запретить всё, что не вписано в строгую типизацию и структуру.
+
+Ошибка с точки зрения диалектики:
+
+- отрицает движение,
+- подавляет противоречие, делает вид, что его нет.
+
+Это как попытаться указом правительства приказать гражданам быть счастливыми в условиях массового нищенского существования.
+
+Противоречие не исчезает — оно вытесняется и возвращается с удвоенной силой.
+
+Пример: в `Pascal` нет прямого доступа к памяти — но это не устраняет потребность в нём, а заставляет нарушать целостность системы в поиске обходных путей, что увеличивает когнитивную нагрузку.
+
+#### Вывод по Pascal
+
+`Pascal` — учит дисциплине, но не учит диалектике.
+
+Он экономит мыслетопливо за счёт ограничения развития.
+
+### `Lisp`
+
+Платонический идеализм: «всё — форма»
+
+Суть: язык — это метаязык, способный породить любую парадигму.
+
+Подход: *код как данные*, *гомоиконичность*, макросы как средство творения нового.
+
+Сила: бесконечная гибкость, возможность создавать языки внутри языка.
+
+Ошибка с точки зрения диалектики:
+
+- Отрыв формы от содержания.
+- Программист может создать идеальную абстракцию, которая не отражает объективную реальность.
+
+Пример: можно написать макрос, который делает (Сложить 2 2) равным 5, если "так удобнее".
+Это — произвол сознания над бытием, чистый идеализм.
+
+Психологический эффект:
+
+- Для эксперта — свобода, полёт мысли.
+- Для новичка — хаос, отсутствие ориентиров, повышенная ошибка из-за семантической неопределённости.
+
+#### Вывод по Lisp
+
+`Lisp` — великий инструмент, но педагогически неустойчив.
+
+- Он развивает, но не направляет.
+- Он гибок, но не контролируем.
+
+### `Rust`
+
+Попытка диалектического перехода
+
+Суть: безопасность не за счёт запрета, а за счёт новой формы организации труда с памятью — владение, заимствование, жизнь.
+
+Подход: `unsafe` как зона сознательного риска, где программист берёт на себя ответственность.
+
+Диалектический момент:
+
+- Противоречие не устраняется, а регулируется через форму.
+- Безопасность и эффективность — единство противоположностей.
+
+Слабость:
+
+- Слишком жёсткая типовая система,
+- Высокий порог входа,
+- Макросы — мощные, но не интегрированы в педагогическую логику.
+
+#### Вывод по Rust
+
+`Rust` — ближе всех к диалектике, но ещё не диалектичен в полной мере.
+
+Он разрешает противоречие, но не развивает программиста как субъекта.
+
+## Критерии выбора для диалектического языка
+
+`Мы ищем не просто «лучший», а наиболее диалектичный`
+
+### Движение
+
+Язык должен развиваться вместе с практикой
+
+### Единство противоположностей
+
+Не запрет, а синтез
+
+### Переход количества в качество
+
+Накопление знаний → переход на новый уровень
+
+### Отрицание отрицания
+
+Язык может порождать новые формы, включая себя
+
+### Практика — критерий истины
+
+Конструкции проверяются реальным использованием
+
+### Экономия мыслетоплива
+
+Минимум когнитивной нагрузки при максимуме понимания
+
+### Сужение семантического контекста
+
+Переход между уровнями — чётко ограничен, предсказуем
+
+### Педагогичность
+
+Язык учит, а не только позволяет
+
+## Синтез: путь к диалектическому языку
+
+Ни один из трёх не идеален.
+
+Но истина — в синтезе.
+
+Наши заимствования:
+
+### Pascal
+
+Чёткость, структура, строгая типизация
+
+Учит дисциплине, снижает хаос
+
+### Lisp
+
+Гибкость, макросы, гомоиконичность, метапрограммирование
+
+Позволяет языку развиваться, порождать новые конструкции
+
+### Rust
+
+unsafe, система владения как основы материалистического перемещения, граница риска
+
+Чёткий семантический контекст перехода
+
+## Проект диалектического решения: prolet, как развивающийся язык
+
+Ключевые черты:
+
+### Гибридная структура с явной границей
+
+```prolet
+(// Высокий уровень — по умолчанию)
+(прц Обработать(Список.Байт данные @мут): Список.Байт
+    (Фильтровать данные
+        (> 10)
+        (* 2))
+)
+
+(// Низкий уровень — только явно, с контекстом)
+(фн Копировать @система(Байт источник
+						Байт цель) (
+        (// Прямой доступ)
+        (асм ....))
+)
+```
+
+### Язык может дополнять себя (по образцу Lisp)
+
+```prolet
+(макрос асинхронно(тело) (
+    (// Трансформация в state machine)
+    (Печать "генерировать_конечный_автомат{тело}")
+)
+
+(// Использование:)
+(асинхронно (Список.Байт данные)(
+    (// Внутри вызова: определение "нечто @фикс")
+    (ОжидатьЗапрос)(уст данные)
+    (ОбработатьДанные))
+)
+```
+
+Язык не статичен — он развивается в процессе использования.
+
+### Система уровней компетенции (по образцу Rust + педагогика)
+
+- Уровень 1: только высокоуровневые конструкции.
+- Уровень 2: можно использовать макросы, но не писать свои.
+- Уровень 3: доступ к низкоуровневый, после прохождения модуля "Память и безопасность".
+
+Переход — не автоматический, а подтверждённый практикой.
+
+### Экономия мыслетоплива в языке
+
+- Минимальный синтаксис для частых операций.
+- Автоматический вывод типов.
+- Контекстное предупреждение при входе в низкоуровневый: "Вы покидаете зону автоматической проверки. Ответственность переходит к вам."
+
+### Сужение семантического контекста в языке
+
+В низкоуровневый блоке:
+
+- Запрещены высокоуровневые коллекции,
+- Нет сборки мусора, но есть освобождение контекста при выходе из области видимости.
+- Только явные операции.
+
+Это сужает мышление до необходимого минимума, снижая вероятность ошибки.
+
+## Заключение: к диалектическому языку будущего
+
+Наиболее диалектичный, экономичный, безопасный и педагогически эффективный подход — это синтез:
+
+- Структура `Pascal` — для порядка,
+- Гибкость `Lisp` — для развития,
+- Граница `Rust` — для ответственности.
+
+Но с принципиальным усилением:
+
+- Язык как организм, способный к саморазвитию через макросы и метаязык,
+- Программист как субъект, проходящий путь от новичка к мастеру,
+- Переход между уровнями — не скачок, а педагогически организованный процесс.
+
+::: success
+Это — не просто язык, это — система воспитания нового программиста:
+
+:::
+
+- способного мыслить диалектически,
+- действовать материалистически,
+- и строить будущее на основе объективных законов.

docs/docs/01_55.md

@@ -0,0 +1,197 @@
+# pro-005-01 Диалектика формы языка программирования
+
+В качестве базовой реализации языка программирования **prolet** принята форма заключение всех сущностей в круглые скобки. На первом месте стоит контекст, имеющий смысл "в заданных границах исполни действие в скобках".
+
+Синтаксис закрепляет онтологический принцип в форме языка.
+
+::: info
+«Исполни контекст в скобках» — это не инструкция, это — утверждение о природе конкретного вычисления как материи в движении.
+
+:::
+
+Разберём решение в свете диалектического материализма, и закрепим его как фундаментальную аксиому языка **prolet**.
+
+## Онтологическая основа: вычисление как процесс
+
+Принцип:
+
+> Только процесс может породить результат.  
+> Нет "значения без действия", нет "сущего без движения".
+
+Форма `(%контекст %аргумент...)` — выражает единство формы и содержания:
+
+- Круглые скобки — граница процесса, как диафрагма в лёгких в разных положениях, разделяющая состояние на вдох и выдох.
+- Первый элемент *контекст* — ограничитель и цель процесса, смысловая нагрузка всей формы, вектор направления.
+- Остальное — аргументы — материалы, подвергаемые преобразованию.
+
+Это — не просто вызов функции,
+это — организация труда над данными.
+
+## Контекст как руководящая сила процесса
+
+Контекст — не синтаксическое украшение, он — руководящее начало, идеологический центр процесса.
+
+- `(фн ...)` -- контекст организация труда по преобразованию, труд через установление порядка
+- `(структ ...)` -- контекст организация материи, создание сложных форм материи
+- `(если ...)` -- контекст поиска сущего в практике, реализация диалектики бытия
+- (... @система ...) -- свойство, задающий условия существования предельно конкретной истины, ограничивает границы возможного конкретного предметного труда
+
+::: info
+Контекст — это границы процесса и руководящая роль в процессе, его деятельная партия: как партия ставит цель, организует ресурсы, руководит исполнением, контролирует процесс и определяет форму результата процесса,  
+но не конкретный результат процесса.
+
+:::
+
+## Круглые скобки — диалектическая граница состояний
+
+Скобки — не просто синтаксис, они — отражение закона перехода количества в качество.
+
+До скобок:
+
+- Данные — потенциальность,
+- Функция — возможность.
+
+Внутри скобок: проявление борьбы и единства противоположностей:
+
+- данные и алгоритм,
+- память и процессор,
+- декларация и действие.
+
+После скобок:
+
+- Результат — новое качество,
+- Состояние изменилось — развитие произошло.
+- Скобки — не разделители, они — граница скачка, момент, когда количество (аргументы, посредством алгоритмов) переходит в качество (результат).
+
+## Единая форма для всех процессов — отражение единства бытия
+
+Отказ от множества синтаксисов (как в `Rust`, `Pascal`, `Python`) в пользу единой формы `(%контекст ...)` — это пример диалектического решения.
+
+### Вычисление
+
+```prolet
+(фн CложитьКм (Км a Км b): Км(
+    (Слож a b)
+)
+```
+
+## Определение структуры
+
+```prolet
+(структ Пользователь
+    @имя     Имя
+    @возраст Возраст)
+```
+
+## Условие
+
+```prolet
+(если (Сравнить x > 0)
+    тогда (Напечатать "положительно"))
+```
+
+## Цикл
+
+```prolet
+(для x в Данные
+    (Удвоить х)(уст результат)
+    (ОтправитьПоПочте результат))
+```
+
+## Диалектический процесс творчества
+
+Форма одна — содержание разное, но все они — процессы в рамках конкретного контекста, все они — формы движения материи.
+
+::: info
+Это — единство противоположностей в синтаксисе: разные по смыслу операции — объединены границей конкретного контекста.
+
+:::
+
+## Почему именно круглые скобки? Материалистическое обоснование
+
+Не фигурные, не квадратные, не без скобок — именно круглые.
+
+- Они замкнуты — отражают целостность процесса, `всё имеет своё начало и свой конец`.
+- Нет углов — символизируют бесконечность форм движения в рамках единого бытия.
+
+Скобки опираются на S-выражения, но это не традиция `Лиспа`, это не повторение его, а диалектическое развитие:
+
+- У **Лиспа**: `(выражение)` — имеет невыразительную форму, часто архаично и местами нарушает единый подход.
+- В **prolet**: `(%контекст ...)` — наделяется одной формой, но разными смыслами.
+- Круг — форма завершённого движения. В нём нет начала и конца — только непрерывное движение с заключённым в него развитием и переходом в рамках одной всеобщей формы.
+
+## Архитектурные последствия решения
+
+### Все конструкции — процессы и функции
+
+Даже определение типа — не декларация, а процесс создания категории бытия.
+
+Даже комментарий — является процессом:
+
+```prolet
+(// Этот модуль отвечает за безопасность пользователей)
+```
+
+### Нет "пассивного кода"
+
+Всё, что в скобках — должно быть исполнено, даже если эффект — регистрация, документирование, проверка.
+
+## Расширяемость через контексты
+
+Новый тип контекста — новая форма организации труда. Пример:
+
+```prolet
+(ПрцПарал ОбогатитьДанные
+    (загрузить)
+    (индексировать))
+
+(прц ОбновитьСчёт(
+    (обновить-счёт)
+    (отправить-уведомление))
+)
+```
+
+Язык не растёт за счёт синтаксиса, а за счёт семантики контекстов.
+
+## 💡 Педагогическое значение формы
+
+Для новичка:
+
+- Легко запомнить: всё — в скобках, первое — что делать.
+- Не нужно учить 10 синтаксисов.
+- Учится мыслить процессуально, а не декларативно.
+
+Для мастера:
+
+- Видит: вся система — сеть процессов.
+- Может анализировать потоки, оптимизировать, рефакторить.
+- Может бесшовно расширять ядро языка
+
+## Заключение: (%контекст ...) как онтологическая аксиома `prolet`
+
+::: success
+Текущее синтаксическое решение — не техническое, но — философское, политическое, революционное.
+
+:::
+
+`(%контекст ...)` — это материалистическая формула вычисления:
+
+- Контекст — знание мира, форма организации действия, руководство процессом,
+- Аргументы — материя, подлежащая преобразованию,
+- Скобки — граница процесса, скачок, развитие.
+
+::: info
+Это — не синтаксис, это — закон языка,
+
+:::
+
+- как закон перехода количества в качество
+- закон отрицания отрицания
+- закон единства и борьбы противоположностей.
+
+### Декларация
+
+- В языке **prolet** всякая конструкция есть *контекст*.
+- Всякий *контекст* начинается с имени и заключён в круглые скобки.
+- Контекст определяет границы и смысл, скобки — форму движения.
+- Нет контекста — нет и конкретного бытия.

docs/docs/01_60.md

@@ -0,0 +1,297 @@
+# pro-006 Диалектическое развитие S-выражений
+
+Как было отмечено ранее, синтаксис предлагаемый с опорой на `Си` / `Rust` не поддерживает (сопротивляется) развитию семантических форм языка. Слишком много форм представления алгоритмов и структур.
+
+Более узкие семантические формы в духе S-выражений (ближе по сути к Лисп), позволяют создавать на единой базе S-выражений предсказуемые по форме выражения, но c широкой по содержанию семантикой.
+
+## Как совместить гибкость и простоту Лиспа с материалистической строгостью и безопасностью, не падая в хаос идеализма?
+
+`Rust` , как мы уже отметили, — это победа формы над мыслью в угоду безопасности.
+
+`Lisp` — победа мысли над формой, но в ущерб практике  и педагогике.
+
+`Pascal` -- при хороших педагогических свойствах не обеспечивает требование развития языка.
+
+Нам же нужен синтез:
+
+- Минимализм `Lisp` в синтаксисе,
+- Материализм диалектики в семантике,
+- Педагогика в структуре,
+- Развитие — в самом языке.
+
+### Новый путь: `prolet` как диалектический минимализм
+
+Основной принцип:
+
+- Один синтаксис — множество смыслов.
+- Форма — минимальна,
+- Семантика — управляема контекстом,
+- Развитие — через метаязык.
+
+Это — не возврат к `Lisp` , а его диалектическое преодоление:
+
+- мы берём гомоиконичность (взаимность представления кода и данных)
+- макросы,
+
+но встраиваем их в рамки объективной реальности — памяти, времени, безопасности, готовности программиста.
+
+## Единая синтаксическая форма: S-выражения с семантической дисциплиной
+
+Вместо множества форм ( `struct` , `enum` , `fn` , `unsafe` , `impl` , `where` и т.д.) — одна базовая конструкция:
+
+```prolet
+(%контекст ...)
+```
+
+**Но!** Семантика определяется *не формой*, а *контекстом* и *свойствами контекста*.
+
+Примеры:
+Функция (высокий уровень)
+
+```prolet
+(фн Обработать (Байты данные)
+    (Фильтровать данные (> 10) (* 2))
+)
+```
+
+Низкоуровневая операция
+
+```prolet
+(фн Копировать  @система(
+		Cис.Адрес ист 
+		Cис.Адрес цель
+		Дом размер)(
+	(асм 
+		(ЦиклОт ист до цель (
+			(рег0 загр ист)
+			(рег1 слож рег0)
+			(рег1 сохр цель))
+	))
+)
+```
+
+### Структура данных
+
+```prolet
+(структ Пользователь
+    @имя      ЧеловекИмя
+    @возраст  ЧеловекВозраст
+    @роль     Роль
+)
+```
+
+Интерфейсный тип
+
+```prolet
+(тип ИФайл
+    (Читать (ФайлИмя имя): Рез.Байты
+      @_док "Читает файл с указанным именем")
+    (Писать (ФайлИмя имя Ос.Права права ): Опт.Ош @мут
+        @_док "Записывает файл с указанным именем и правами")
+)
+```
+
+Все конструкции — одного синтаксического вида, но семантика управляется *контекстом в начале*:
+
+- `фн` (функция),
+- `структ` (структура),
+- `система` (низкоуровневый),
+- `тип`.
+
+## Узкие семантические формы: от простого к сложному
+
+`Мы не устраняем сложность, но последовательно её раскрываем.`
+
+### Уровень 1: Новичок
+
+Доступны только:
+
+- (прц ...)
+- (фн ...)
+- (спис ...),
+- (словарь ...),
+- (если ...),
+- (для ...)
+
+Нет доступа к:
+
+- (@система),
+- (асм),
+- (макро).
+
+```prolet
+(фн Приветствовать (ГостьИмя имя)
+  (Печатать "Привет, " имя "!"))
+```
+
+Простота Лиспа, но в безопасной оболочке диалектического языка.
+
+### Уровень 2: Стажёр
+
+Открываются:
+
+- (структ ...)
+- (тип ...)
+- (макрос ...)
+- (форма ....)
+
+```prolet
+(структ Точка
+    @x ПозX
+    @y ПоpY)
+
+(макрос когда (условие тело)
+  (если условие
+    тогда (Выполнить тело)
+    иначе (Выполнить тело))
+)
+```
+
+Язык начинает развиваться, но в рамках контролируемой системы.
+
+## Уровень 3: Мастер
+
+Разрешён:
+
+- (@система ...)
+- (асм ...)
+- (система-вызов ...)
+- (адр ...)
+
+```prolet
+(прц @система КопироватьПамять (
+    	Сис.Адр цель 
+    	Сис.Адр источник @мут 
+    	Сис.Колич длина)(
+	(асм (рег3 сохр длина))
+    (асм (ЦиклОт рег0 до рег2
+			(...))
+	))
+)
+```
+
+**Но!** Такой код не компилируется без:
+
+- одобрения ревью,
+- ссылки на стандарт (например, "форма драйвера PCI"),
+- пометки обоснования @причина "взаимодействие с железом".
+
+## Семантическая экономия: один синтаксис — разный смысл по контексту
+
+```prolet
+(спис 1 2 3)
+(структ Пользователь)
+(выраж ...)
+(тип Проверятор)
+(список Цел 1 2 3)
+(структ ПользовательНов
+  @имя     "Анна"
+  @возраст 28
+  @роль    Админ)
+(уст ...)
+(<ИмяФункции>)
+(ЕслНечто нечто как ИФайл)
+```
+
+Это — диалектическая гибкость: форма одна, но смысл возникает в практике применения, а не в синтаксической избыточности.
+
+## Макросы как средство развития языка (по образцу Лиспа, но с контролем)
+
+Макросы — не анархия, а организованное развитие.
+
+```prolet
+(макрос конкурент (тело...)
+  (поток (тело))
+  @_док "Запускает конкурентно тело выражения")
+
+(конкурент
+  (ЗагрузитьДанные)
+  (ОбновитьИнтерфейс))
+```
+
+Но:
+
+- Макросы только в модулях уровня 2+,
+- Должны быть задокументированы,
+- Не могут переопределять базовые формы (`если`,  `функция` и т.п.).
+
+Это — революционное преобразование старой формы со свободным содержанием, в новую форму с дисциплиной смысла.
+
+## Сужение контекста перехода: как программист "спускается"
+
+Переход на низкий уровень — не синтаксическое волшебство, а сознательный акт:
+
+```prolet
+(фн @система СложитьАдреса (Сис.Адр a Сис.Адр b)
+  @_обоснование "оптимизация критического участка"
+  @_требует_ревью
+  @_уровень_доступа 3
+    (Сложить (Сис.Извлечь a)
+             (Сис.Извлечь b))
+)
+```
+
+Что даёт такая форма:
+
+- Семантически сужает контекст: только указатели, только арифметика.
+- Фиксирует ответственность: обоснование, ревью, уровень.
+- Экономит мыслетопливо: нет лишних слов, только суть.
+- Педагогически настраивает: программист осознаёт, что делает.
+
+## Сравнение подходов: почему это диалектичнее
+
+### Синтаксическая сложность
+
+- `Lisp` Очень низкая
+- `Rust` Высокая
+- `prolet` Низкая
+
+### Семантическая ясность
+
+- `Lisp` Низкая (всё — список)
+- `Rust` Высокая (много форм)
+- `prolet` Высокая (контекст + тег)
+
+### Гибкость
+
+- `Lisp` Деструктивно высокая
+- `Rust` Ограниченная
+- `prolet` Высокая (макросы + уровни)
+
+### Безопасность
+
+- `Lisp` Нет
+- `Rust` Высокая
+- `prolet` (по уровням, от минимальной до высокой)
+
+### Развитие языка
+
+- `Lisp`  доступно индивидуально
+- `Rust` Через RFC
+- `prolet` Через макросы + одобрение сверху
+
+### Экономия мыслетоплива
+
+- `Lisp` Высокая для экспертов, низкая для новичков
+- `Rust` Низкая (много правил)
+- `prolet` Высокая для всех (одна форма; много фиксированных смыслов в конкретном контексте)
+
+### Педагогичность
+
+- `Lisp` Низкая
+- `Rust` Недостаточная
+- `prolet` Высокая (постепенное раскрытие)
+
+## Заключение: язык как диалектический инструмент
+
+Приведённый синтез формы из трёх языков, соответствует духу диалектического материализма:
+
+- Форма — лисп-подобная: одна, чистая, минимальная.
+- Семантика — материалистическая: определяется практикой, контекстом, уровнем развития.
+- Переход между уровнями — не скачок, а педагогически организованный процесс.
+- Язык — не замороженный объект, а развивающийся организм.
+
+Это — не упрощение, а углубление диалектики:
+
+- мы не множим формы,
+- мы углубляем понимание единства и борьбы противоположностей в самом акте программирования.

docs/docs/01_70.md

@@ -0,0 +1,231 @@
+# pro-007 Диалектика развития языка
+
+В духе диалектического материализма, прототип предложенного решения оснастим ещё большей выразительностью. А именно: рассмотрим вариант синтаксиса, где базовая часть ядра языка заметно (но ненавязчиво) отличается от той части, что предлагает программист в виде своего кода. Чтобы снять противоречие старого и нового, неподвижного (и малоподвижного) от движущегося.
+
+Необходимо выполнить не просто синтез противоположностей, а разделение старого и нового на уровне внутренней семантики формы, чтобы сама структура языка отражала закон отрицания отрицания.
+
+## Единообразие внешней формы и разделение по внутренней форме
+
+Если язык претендует на диалектичность, он не может быть полностью единообразным в любой форме. Он должен материально выражать противоречие между устоявшимся и возникающим, между ядром-основой и творческим дополнением, между материей прошлого и сознанием будущего.
+
+### Диалектический принцип
+
+- Ядро языка — неподвижно (в пределах версии), но совместимо (в пределах всех версий)
+- Расширение — подвижно,
+- Но движущееся порождается из неподвижного, отрицает его,
+- И в своём развитии — отрицает отрицание,
+
+поднимая язык на новый уровень.
+
+::: info
+Это — не просто метапрограммирование, это — организация языка как классовой борьбы между консервацией прошлого и революцией настоящего в сфере сознания.
+
+:::
+
+## Новый проект: prolet с разделённой формой существующего и нового
+
+Два слоя синтаксиса:
+
+### Ядро (Базис)
+
+- Устойчивая основа: типы, управление, память, вызовы
+- Последовательная разработка ядра на основе реальных потребностей
+- Объективный подход ко всем аспектам языка
+
+### Расширение (Творчество)
+
+- Развитие: новые парадигмы, DSL, оптимизации, замена частей ядра
+- Частные расширения синтаксиса но основе текущих потребностей
+- Субъективная инициатива
+
+Это — единство и борьба форм,
+где форма выражает содержание диалектики.
+
+## Ядро: стабильное, проверенное, материалистическое
+
+Основано на S-выражениях, как в Лиспе, но семантически строго:
+
+```prolet
+(// Если не указан атрибут изменяемости -- по умолчанию @фикс)
+(фн Cложить (Час a Час b)(
+    (СложитьЧас a b))
+)
+
+(структ Пользователь
+    @имя     ЧеловекИмя
+    @возраст ЧеловекВозраст)
+
+(если (Сравнить x > 0)
+  тогда (Напечатать "Положительно")
+  иначе (Напечатать "Ноль или отрицательно"))
+```
+
+Особенности ядра:
+
+- Неизменно в рамках версии 1.x.
+- Компилируется во внутреннее представление напрямую.
+- Не может быть переопределено, но может быть перекрыто частным определением.
+- Создаётся централизованно на основе теории и практики.
+
+::: info
+Это — материальная база, как производительные силы в экономике — нельзя менять каждый день, но можно развивать в следующей версии, с развитием производственных отношений.
+
+:::
+
+## Расширение: творческое, подвижное, диалектическое
+
+Работает в таких же круглых скобках, где сопровождающий контекст `макро` означает расширение, развитие, отрицание старого на уровне пользователя. Расширение способно заменить в текущей программе более высокоуровневые реализации.
+
+Внутри — новые формы, DSL, макросы, оптимизации. Снаружи -- прежний синтаксис.
+
+```prolet
+(макро параллельно (
+  (ЗагрузитьДанные)
+  (ОбновитьИнтерфейс))
+)
+
+(макро SQL "SELECT * FROM пользователи WHERE возраст > ?" возраст }
+```
+
+Как это работает: `параллельно` — не ключевое слово, а расширение, определённое в пользовательской библиотеке, на том же уровне.
+
+Это — народное творчество, как массовое движение, которое не ломает основу, но вносит новое содержание.
+
+## Разделение форм: философская и практическая необходимость
+
+### Формы ядра
+
+- Форма: `(операция аргументы)`
+- Изменяемость: Запрещена в версии
+- Компиляция: На этапе 1
+- Авторство: разработчики ядра
+- Ответственность: Гарантирована
+- Жизненный цикл: Долгий (версии 1.0, 2.0)
+
+### Формы пользователя
+
+- Форма: `(макро содержание)`
+- Изменяемость: Разрешена, по согласованию
+- Компиляция: На этапе 2 (после ядра)
+- Авторство: Сообщество, отдельные разработчики
+- Ответственность: На авторе расширения
+- Жизненный цикл: Краткий (пробный, экспериментальный))
+
+Это — диалектическое разделение труда в языке:
+
+- Ядро — закон,
+- Расширение — инициатива,
+- Их единство — развитие.
+
+## Переход от старого к новому: процесс отрицания
+
+Пример: появление нового цикла в потоках (старое ядро):
+
+```prolet
+(для задача в списокЗадач
+    (СоздатьПоток задача))
+```
+
+После проверки практикой — включение в ядро новой версии (расширение):
+Новое (расширение):
+
+```prolet
+(параллельно (Выполнить списокЗадач))
+```
+
+Это — отрицание отрицания:
+
+- Старое `(для ... СоздатьПоток)` — отрицается,
+- Новое `(параллельно ...)` — отрицает старое,
+
+Но затем `(параллельно ...)` само отрицается — становится частью ядра, и появляется новое расширение для асинхронных потоков.
+
+## Психологическая и педагогическая выгода
+
+Для новичка:
+
+- Видит только `(...)` — простота, порядок, безопасность.
+- Расширения скрыты или отключены.
+
+Для мастера:
+
+- Может писать `(макро ...)`, на пользовательском уровне, но осознаёт, что это — эксперимент, что он выходит за рамки устоявшегося, что за это несёт ответственность. При компиляции получает уведомление (если не подавлено атрибутом)
+
+Расширения разработчиками ядра могут быть:
+
+- Одобрены,
+- Отклонены,
+- Включены в следующую версию ядра.
+
+Это — демократический централизм в действии.
+
+## Реализация на уровне компилятора
+
+Этап 1: Парсинг ядра
+
+- Обрабатывает только системные библиотеки, строит **AST**.
+- выполняет предварительную компиляцию ядра (однократно)
+
+Этап 2: Макро-раскрытие расширений на уровне пользователя
+
+- Находит `(макро ...)`, подставляет определение из зарегистрированных расширений.
+
+Этап 3: Трансляция в ядро
+
+- Все пользовательские макросы интегрируются в ядро.
+
+Этап 4: Компиляция
+
+- только изменившийся код.
+- сборка готовых модулей.
+
+::: info
+Таким образом, вся сложность остаётся контролируемой, сборка занимает незначительное время, а инновации не разрушают стабильность.
+
+:::
+
+## Пример полного кода
+
+```prolet
+(// === ЯДРО === )
+(фн ОбработатьПакет (СписокДок пакет)(
+    (если (ПроверитьЦелостность пакет)
+        тогда (Расшифровать пакет)
+        иначе (Остановить "битый пакет")
+	))
+)
+
+(// === РАСШИРЕНИЕ === )
+(структ ВебСервер
+  @маршрут ВебОбработчик
+  @порт    СетьПорт
+)
+
+(Печатать "Запуск сервера...")
+```
+
+Здесь:
+
+- (фн ...) — ядро, стабильно,
+- (ВебСервер ...) — использование результатов творчества, может измениться,
+- (Печатать ...) — может быть переопределён под нужды среды, вместо реализации ядра
+
+## Заключение: язык как диалектическая система
+
+- Форма ядра `(...)` — отражает устоявшееся, необходимое, объективное.
+- Форма расширения — `(макро ...)` — отражает возникающее, творческое, субъективное.
+
+::: success
+Их борьба и единство — двигатель развития.
+
+Переход расширения в ядро — качественный скачок.
+
+Разделение форм — материальное выражение закона отрицания отрицания.
+
+:::
+
+Это — не просто язык программирования, это — модель социалистического информационного общества:
+
+- стабильный базис,
+- свободное изменение по необходимости,
+- и путь от частного к общему через практику.

docs/docs/01_80.md

@@ -0,0 +1,330 @@
+# pro-008 Диалектика динамики типов
+
+Рассмотрим более подробно ещё одно диалектическое противоречие: "статическая типизация -- динамическая типизация". Надо получить ясный, структурированный переход между строгой статикой и высокой динамикой. А также предусмотреть контролируемый механизм перехода из одного состояния в другое.
+
+Это не просто технический выбор между безопасностью и гибкостью, а борьба форм отражения объективной реальности в сознании программиста.
+
+- Статика — стремление к порядку, предсказуемости, закону.
+- Динамика — стремление к адаптации, изменению, практике.
+
+::: info
+Их единство — не компромисс, а диалектический переход, где каждая сторона отрицает другую, чтобы породить нечто высшее.
+
+:::
+
+## Постановка противоречия
+
+### Плюсы
+
+- статическая типизация: Безопасность, производительность, документация в коде
+- динамическая типизация: Гибкость, быстрая разработка, адаптивность
+
+### Минусы
+
+- статическая типизация: Жёсткость, сложность, высокий порог входа
+- динамическая типизация: возможны ошибки на этапе исполнения, трудно масштабировать, слабая документация
+
+## Философия
+
+- статическая типизация: идеализм порядка (мир должен быть упорядочен)
+- динамическая типизация: идеализм вечного изменения (мир — поток, форма не важна)
+
+Ни одна сторона не может победить полностью.
+
+::: info
+Победа — в синтезе, в контролируемом переходе от одной формы к другой, в зависимости от объективных условий задачи.
+
+:::
+
+**Цель**: `диалектическая типизация`
+
+Не смешение статики и динамики, а их единство в движении, где:
+
+- Статика — норма,
+- Динамика — вынужденное отклонение,
+- Переход — не хаос, а сознательный, контролируемый, документируемый акт.
+
+## Основные принципы диалектической типизации
+
+### Статика по умолчанию
+
+Вся переменная, функция, структура — строго типизированы.
+
+### Динамика — как отрицание нормы
+
+Разрешена только в явно обозначенных зонах.
+
+- Переход — через форму, а не через волю
+- Не просто `any`, а структурированный механизм
+
+## Обратный переход — обязательный
+
+Из динамики можно выйти только через проверку и приведение типа.
+
+### Контекст определяет
+
+- В ядре системы — только статика.
+- В интерфейсе с внешним миром — динамика разрешена.
+
+### Педагогический контроль
+
+Новичок не может использовать динамику без одобрения.
+
+## Механизм перехода: "шлюз"
+
+Введём новую конструкцию — `шлюз`,
+который ограничивает пространство и время действия динамики.
+
+Динамический шлюз -- это форма диалектического преодоления несовершенства внешнего мира.
+
+`@шлюз_вход`, `@шлюз_выход` — это не просто синтаксический сахар, это — граница между мирами, между упорядоченным миром `prolet` и хаосом внешних данных, между типизированным бытием и бестиповым небытием.
+
+Шлюз не всегда требуется при обмене с внешним миром. Если приём данных из внешнего источника из экосистемы `prolet` -- тогда такой поток байтовых данных будет сопровождаться метками типа. В этой ситуации шлюз не нужен.
+
+```prolet
+(// Внутри — следует использовать байтовый поток, 
+		тип на выходе -- `нечто`)
+(ВебЗапросить "/data"
+    @шлюз_вход
+    @требует_ревью)(уст нечто)
+(// тип: фиксированный срез байтов)
+
+(// Обратный переход — только через проверку)
+ (ЕслиНечто нечто как Структ.Пользователь
+    тогда (
+		(Привести нечто к Пользователь)
+		(уст пользователь))
+    иначе (ПечатьОшибка "неверный формат")
+)
+```
+
+Особенности шлюза:
+
+- всегда принимает поток байт.
+- прекращает работу, если свойство `@шлюз_вход` не указано, а формат байтового потока не имеет меток типов полей.
+- Запрещён в критических модулях (ядро, безопасность).
+- Только после ревью (для уровней < 3).
+
+Это — не либерализм, а учёт требований объективной реальности, как *военный коммунизм → нэп → социализм*.
+
+Суть `@шлюз_вход`: граница между мирами
+
+🌍 Два мира:
+
+| МИР PROLET                  | ВНЕШНИЙ МИР                   |
+|-----------------------------|-------------------------------|
+| Типы — первичны             | Типы — отсутствуют или скрыты |
+| Данные — структурированы    | Данные — байтовый поток       |
+| Порядок — внутренний        | Хаос — норма                  |
+| @конст, @фикс, @мут — везде | Никаких категорий             |
+
+`@шлюз_вход` — это не функция, это — онтологическая граница, где байт становится сущим, а хаос — формой порядка.
+
+## Динамический тип, как переходное состояние
+
+Динамический тип — не тип-ловушка, а тип-процесс.
+
+Он не может участвовать в вычислениях напрямую. Чтобы использовать — нужно привести к статическому типу.
+
+```prolet
+(// по умолчанию статичность на выходе @фикс, 
+	параметр контакта с внешним миром -- @шлюз_вход)
+(ПолучитьИзApi)(уст x)
+
+(// Ошибка: (x + 1) — запрещено)
+(ЕслиНечто x как Целое
+    тогда (ОбработатьЧисло (Привести x в Целое))
+    иначе (ПечатьОшибка "ожидалось число")
+)
+```
+
+Это — материалистическое требование: чтобы работать с реальностью, нужно понять её структуру.
+
+Если данные пришли от другого `prolet`-процесса, и сериализованы с метаданными (структуры в духе `prolet`), то `@шлюз_вход` не нужен — это внутренний поток выраженный иными средствами для внешнего хаотического мира, как товарообмен в социалистическом хозяйстве между различными предприятиями в одной цепочке производства и в одной стране, но разных городах.
+
+Но если данные — извне:
+
+- JSON без схемы,
+- бинарный протокол,
+- CSV,
+- XML с xsi:type="string"
+
+  тогда нужен `@шлюз_вход`, потому что форма несёт в себе противоречие: `байты есть, а типов — нет`.
+
+## Система приведения типов: "путь к статике"
+
+Проверка типа:
+
+- `(ЕслиНечто х как Пользователь)` Булево, безопасно
+- Безопасное извлечение типа
+
+```prolet
+(ЕслиНечто х как Пользователь)
+    тогда (Обработать (Привести х в Пользователь))
+    иначе (ПечатьОшибка "ожидался пользователь"))
+```
+
+Приведение с проверкой `(ТипКонверт х в Пользователь)(уст х @мут)` Падает, если не подходит.
+
+### Функциональный стиль
+
+Схемная валидация для сложных форматов:
+
+```prolet
+(ЕслиНечто байты к Схема.Пользователь
+    тогда (
+		(Привести байты в Схема.Пользователь)
+		(уст х))
+    иначе (ПечатьОшибка "ожидалось число"))
+```
+
+Переход из динамики в статику — не автоматический, а требующий сознательного усилия, как переход от чувственного восприятия к рациональному пониманию.
+
+## Контекстно-зависимая типизация: где разрешена динамика?
+
+- ввод: файлы (Внешний мир не контролируется)
+- ввод: внешние __API__ (не из экосистемы)
+- ввод: конфигурация (не из экосистемы)
+
+::: info
+Это — не абсолютизация, а диалектический релятивизм: истина — в конкретной практике, границы которой задаются контекстом.
+
+:::
+
+## Развитие типов: от динамики к статике через практику
+
+Когда динамический интерфейс стабилизируется, его можно возвысить до статического закона:
+
+```prolet
+(// Сначала — динамически, 
+	"ЗапросАпи" определён как @шлюз_вход, и данные как @фикс)
+(прц ЗапросАпи @шлюз_вход(): нечто(
+	....)
+)
+(ЕслиНечто нечто как Схема.ФорматV1
+        тогда (...)
+        иначе (...))
+
+(// Через месяц практики — выносим в структур)
+(структ ФорматV1
+  @поле1 Накладная.Название
+  @поле2 Список.Целое)
+
+(// Использование через приведение, результат определён как @фикс)
+(ЕслиНечто х как ФорматV1
+    тогда (
+		(ЧитатьИз "data/sample.json")
+		(уст конфигТекст))
+)
+```
+
+Это — отрицание отрицания: динамика отрицает статику, но на основе практического действия — порождает заново безопасную статику.
+
+## Почему именно `@шлюз_вход`, а не просто функция?
+
+Потому что:
+
+- Это — не вычисление,
+- Это — переход количества в качество,
+- Это — восстановление формы из хаоса.
+
+::: info
+Как у диалектики: `Из хаоса — порядок, из количества — качество`.
+
+:::
+
+## Почему `@шлюз_вход` — однонаправленный?
+
+Потому что:
+
+- Вход — из байт → в типизированное сущее — требует труда, проверки, интерпретации.
+- Выход — из `prolet` → в байты — может быть автоматическим, если используется самоописывающий формат (например, `prolet-bin` с метками типов).
+
+Но если выход — в неструктурированный формат (например, `raw TCP`), то нужен обратный шлюз — `@шлюз_выход`:
+
+```lisp
+(фн Отправить (Пользователь x)
+    @шлюз_выход
+    @цель legacy_система(
+   (СериализоватьБезТипов x)
+)
+```
+
+Это — единство и борьба: вход и выход — разные по природе, потому что мир в динамике асимметричен.
+
+## Что делает `@шлюз_вход` на уровне ВМ?
+
+При встрече `@шлюз_вход`:
+
+- Активируется режим проверки:
+- Все значения извне — являются срезом байт.
+- Нельзя использовать напрямую.
+
+Требуется явное приведение:
+
+- `(Привести х в Пользователь)` → с проверкой.
+- Или — `(ЕслиНечто ... как Схема.ХХХ)`.
+
+Фиксируется событие:
+
+- В лог: `(@шлюз_выход @логОткл)` (по умолчанию активно).
+- В граф жизненного цикла — новая ветвь анализа.
+
+## Психологические и педагогические механизмы
+
+💡 Для новичка:
+
+- Динамика отключена.
+- При попытке использовать — подсказка: "Динамические типы доступны после прохождения модуля 'Работа с внешними данными'".
+
+💡 Для мастера:
+
+- Можно использовать динамический шлюз,
+- но только с обоснованием, и с автоматическим логированием всех операций (включено по умолчанию).
+
+💡 Для системы:
+
+- Все динамические участки автоматически документируются.
+- Нет идеалистических типов данных (всегда присутствует байтовый поток).
+- При стабилизации — предлагает: "Этот шлюз использован 100 раз. Создать статический тип?" (возможна автоматическая генерация обратимого конвертера)
+
+## Пример: полный цикл перехода
+
+```prolet
+(// Внешний API — неизвестная структура)
+(ВебЗапросить "https://api.partner/data" @шлюз_вход)
+(уст нечто)
+
+(// Проверка и переход к статике)
+(ЕслиНечто нечто как Схема.АнализДанных)
+    тогда (
+		(Привести нечто в Схема.АнализДанных)
+		(уст отчёт @мут)
+        (ОтправитьОтчёт отчёт))
+    иначе (ПечататьОшибку "некорректные данные"))
+
+(// Определение типа на основе практики)
+(структ АнализДанных
+  @показатель ПроцентПлана
+  @дата       АбсолютнаяМетка
+  @регион     РегионПеречисление
+  @_док       "Анализ данных по регионам с привязкой по времени")
+```
+
+От хаоса внешнего мира → к порядку внутренней системы через безопасные однонаправленные шлюзы.
+
+## Заключение: типизация как диалектический процесс
+
+Предлагаемое решение не устраняет противоречие, а развивает отношения внутренних форм в конкретной ситуации:
+
+- Статика — не догма, а результат победы над хаосом.
+- Динамика — не свобода, а временное отступление перед объективной необходимостью, но без отрыва от реальности.
+- Переход — не скачок, а контролируемый, документируемый, педагогически организованный процесс.
+- Язык — не набор правил, а механизм познания реальности через типы.
+
+::: success
+Это — не просто типовая система, это — диалектика познания:
+
+*от незнания → к гипотезе (динамика) → к истине (статика).*
+
+:::

docs/docs/01_90.md

@@ -0,0 +1,248 @@
+# pro-009 Диалектическая несостоятельность nil
+
+Очередное диалектическое противоречие для рассмотрения `сущее - не сущее`. Ошибка на миллиард долларов в нашем новом, диалектическо-материалистическом языке недопустима. Наша модель языка должна отражать реально существующий мир.
+
+Рассмотрим корень диалектического материализма, его онтологическую основу:
+
+- `Сущее` vs `не сущее`,
+- `Бытие` vs `Небытие`,
+- `Материя` vs `Пустота`,
+- `Наличие` vs `Отсутствие`.
+
+Это не просто «обработка nil» — это фундаментальное противоречие, лежащее в основе всего сущего. И если мы хотим построить язык, который отражает реально существующий мир, а не идеальный мир платоновских форм, то мы обязаны решить это противоречие диалектически, а не технически, или прагматически, или сугубо субъективно.
+
+## Философская основа: "сущее и не сущее" в диалектическом материализме
+
+### Материя первична — сущее есть
+
+В диалектическом материализме только *объективно существующее* — *есть*.
+
+Всё остальное — отражение, потенциальность, но не `бытие`.
+
+`Сущее` — это то, что взаимодействует с миром, что занимает место в пространстве-времени, что оказывает воздействие.
+
+`Не сущее` — это отсутствие материи, небытие, ничто.
+
+Но! Диалектика учит: ничто не возникает из ничего, и ничто не исчезает в ничто.
+
+Следовательно, `не сущее` — не абстракция, а момент развития материи вне установленных философских категорий -- `нечто`.
+
+### Противоречие в программировании: null, undefined, None, nil
+
+В большинстве языков: `nil` — это "значение, которое не есть значение".
+
+Это — онтологическая ошибка: признание существования небытия как равноправного с бытием.
+
+Пример катастрофы:
+
+```java
+// может быть null
+String name = user.getName();
+
+// NullPointerException — ошибка на миллиард долларов
+int len = name.length();     
+```
+
+Это — не ошибка программиста, это — ошибка *онтологии языка*, который допускает, что `не сущее` может передаваться как `сущее`.
+
+## Идеалистические ошибки в типизации "сущее/не сущее"
+
+### C/C++
+
+`NULL` — указатель в никуда
+
+Допускает использование "ничего" как "чего-то"
+
+### Java/Python
+
+`null`/`None` — объект-пустота
+
+Придаёт небытию форму бытия
+
+### Haskell
+
+`Maybe a` — чисто, но абстрактно
+
+Отделяет форму от материи
+
+### Rust
+
+`Option<T>` — шаг вперёд, но не до конца
+
+`None` — всё ещё "значение", хотя и обёрнуто
+
+**Все они** — идеалистические компромиссы:
+
+- признают небытие как форму бытия,
+- вместо того, чтобы разрешить противоречие через практику.
+
+## Диалектическое решение: "сущее" и "нечто" как реально существующие противоположности в движении
+
+Принципы онтологии языка `prolet`:
+
+- Только `сущее` может быть значением.
+- Если чего-то нет — оно не может быть передано, не может быть переменной, не может быть в вычислении.
+- `нечто` — не значение, а реально существующее состояние процесса.
+- Оно не существует само по себе, а возникает в практике получения сущего без формы.
+- Переход от `нечто` к `сущему` — через труд, проверку, практику.
+- Как в жизни: хлеб не берётся из воздуха — он выращивается, обрабатывается, доставляется.
+- Язык не допускает "пустоту" как объект — он требует решения.
+
+Нет `null`. Нет `None`. Есть `нечто` как сущее, но неопределённое.
+
+## 📔 Механизм: нечто — тип, как пространство поиска сущего
+
+Вместо `Option<T>` или `null` — вводим сущность `нечто`, которая является типом, обозначает пространство неопределённости, в котором ещё не решено, есть ли сущее. Но сама содержащая неопределённость сущность `нечто` -- существует всегда.
+
+```prolet
+(// 1. Внешний источник — может не дать сущего,
+если шлюз принимает данные не от prolet-процесса)
+(прц ЗапросИзАпи @шлюз_вход(): нечто
+    ...)
+)
+
+(// Внутри `нечто` — нельзя использовать напрямую,
+		ОШИБКА КОМПИЛЯЦИИ )
+(ОбработатьДанные)
+(уст нечто)
+
+(// Переход к сущему — только через практику)
+(ЕслиНечто нечто как Пользователь
+		(// нечто — теперь сущее)
+    тогда (
+		(Привести нечто к Пользователь))
+		(Пользователь Обработать)
+		(// нет сущего — альтернатива)
+    иначе (Пользователь ПоУмолчанию)) 
+```
+
+Ключевые особенности:
+
+- `нечто` — тип для определения пространства возможного.
+- Переменная `нечто` имеет значение до проверки, но не имеет определённого типа
+- После контекста `ЕслиНечто` — в ветке `тогда` переменная становится сущей.
+- В ветке `иначе` — альтернативное действие.
+
+Это — единство бытия и небытия в процессе познания:
+
+- пока не проверили — нечто, а не сущее,
+- после проверки — сущее возникает как результат практики.
+
+## Онтологическая строгость: никакого "значения-пустоты"
+
+Сравните:
+
+### ❎ Небытие-значение (ошибка)
+
+```Java
+String s = null;
+```
+
+### ⚠️ Небытие — обёрнуто, но существует (потенциальная ошибка)
+
+```Rust
+let s: Option<String> = None;
+```
+
+### ✔️ Нечто — не значение, а состояние поиска
+
+```prolet
+(прц ИзПорта @шлюз_вход (...): нечто
+	(...)
+)
+```
+
+В `prolet` нельзя написать:
+
+```lisp
+(Пусто)(уст дыра @мут) (// ОШИБКА: "ничего" не есть)
+```
+
+Потому *что ничего не есть*.
+
+## Практическая реализация: три формы работы с *не сущим*
+
+### Форма 1: Проверка (познание через практику)
+
+```prolet
+(НайтиПоНомеру (123 125)(уст нечто)
+
+(ЕслиНечто нечто как Пользователь
+    тогда (
+		(Привести нечто к Пользователь)
+		(уст пользователь)
+        (напечатать "Здравствуй, " пользователь имя))
+    иначе (напечатать "Пользователь не найден"))
+```
+
+Только после проверки — пользователь становится сущим.
+
+## Форма 2: Принудительное извлечение (с ответственностью)
+
+```lisp
+(фн ПрочитатьФайл @шлюз_вход() -> нечто)
+
+(ГарантНечто нечто как Пользователь
+    @_док "данные обязательны, иначе сбой конфигурации"
+    иначе (
+		(Пользователь Новый)
+		(уст пользователь))
+))
+```
+
+Гарантировать — не отрицание онтологии, а утверждение сущего на основе практики.
+
+Но требует введения небытия и работает только в контролируемых условиях.
+
+## Педагогический и психологический аспект
+
+- Новичок не может использовать `нечто` без `ЕслиНечто`.
+- `ГарантНечто` вернёт сущее.
+
+**IDE** подсвечивает:
+
+- "Переменная `нечто` — не содержит конкретной формы. Проверьте перед использованием."
+- При попытке передать `нечто` в функцию, ожидающую сущее — ошибка компиляции.
+
+Это — формирование диалектического сознания: программист учится не признавать пустоту как бытие, а искать сущее в практике.
+
+## Философское обобщение: онтология языка
+
+### Бытие
+
+- Только то, что существует, имеет форму, действует
+- Переход от `нечто` к `сущему` через проверку
+
+### Небытие
+
+- Не может иметь форму
+- Нет возможности перехода к сущему, и даже к нечто
+
+### Ошибка онтологии
+
+::: info
+Не использование `nil`, а признания небытия как невозможное в реальном мире. Язык не допускает онтологической лжи.
+
+:::
+
+Он требует:
+
+- Либо — сущее,
+- Либо — честное признание, что его ещё нет,
+- Либо — создание альтернативного сущего.
+
+## Заключение: язык как отражение реального мира
+
+Дано решение главного противоречия:
+
+`prolet` не допускает ошибки на миллиард долларов, потому что он не допускает лжи онтологии.
+
+- В нём нет места `nil`, потому что *ничего не есть*.
+- В нём есть место практике, потому что сущее рождается в труде.
+- В нём есть место неопределённости, но не как значению, а как пространству поиска.
+- В нём программист — не маг, а труженик, добывающий сущее из потенциально сущего.
+
+::: success
+Это — не просто безопасность, это — материалистическая честность, это — диалектика бытия, воплощённая в синтаксисе.
+
+:::

docs/docs/02_10.md

@@ -0,0 +1,309 @@
+# pro-010 Диалектическая онтология типов
+
+Диалектическая онтология типов подчиняется тем же законам, что и весь диалектический материализм.
+
+- От отрицания простого, к снятию противоречия в виде сложного.
+- От базового, к универсальному.
+
+Диалектическая онтология типов как отражение структуры объективной реальности.
+
+Мы уже отвергли идеалистические перекосы:
+
+- `nil` как "сущее небытие",
+- динамика как хаос,
+- синтаксис как идеалистическая бюрократия.
+
+Но теперь настал момент синтеза:
+
+- от отрицания простого (примитивных типов)
+- к снятию противоречия в форме сложного, универсального, развивающегося
+
+к диалектической онтологии типа.
+
+## Диалектический путь развития понятия "тип"
+
+### Простое (метафизика)
+
+Тип — ярлык, классификация. Неподвижен.
+
+`int` , `string` , `bool`
+
+::: info
+Противоречие: Простые типы не отражают сложность мира. Возникает потребность в составных. Простые типы поглощаются составными.
+
+:::
+
+`struct` , `type` , `tuple`, `list`
+
+Кроме того, `Целое` — как простой тип не просто число, а объект с поведением. Поведение объекта, способы взаимодействия с миром определяются свойствами самого объекта. С другой стороны, те же свойства объекта диалектически накладывают ограничения на тот же объект.
+
+### Снятие противоречия (синтез)
+
+Базовый тип-процесс, отношение, структура в движении. Универсальный тип, порождающий себя и служащий строительным материалом для порождения других типов.
+
+Это — не эволюция, а революция в мышлении:
+
+- тип перестаёт быть статической меткой,
+- и становится формой существования материи в информационной сфере.
+
+> `Целое` не просто как один из типов, а как фундаментальный тип реальности.
+
+## Критика метафизического подхода к типам
+
+Ошибка: тип как "вещь в себе"
+
+В `C` , `Java` , `Python` : `int` — это нечто отдельное, не связанное с практикой.
+
+Но в реальности:
+
+- Целое в банковской системе ≠ Целое в физике частиц,
+- Строка в **UI** ≠ Строка в криптографии.
+- Метафизика абстрагируется от содержания,
+- идеализм отрывает форму от материи.
+
+Нет никакого абстрактного `int` . Есть:
+
+- число яблок
+- число груш
+- число аршин сукна
+
+Это всё целые числа, но это *разные* целые числа. Нельзя складывать *число яблок* с *числом груш*. Это разные *числа*. Но, складывая эти разные числа -- можно получить *число фруктов*, как число нового типа.
+
+::: warn
+Важное замечание: арифметический знак `+` при подобном сложении будем неадекватным, так как не отражает *диалектический процесс превращения* одного вида материи в другой.
+
+:::
+
+## Диалектическая онтология типа: тип как единство формы, содержания и практики
+
+Принципы:
+
+### Тип — не ярлык, а категория бытия
+
+Отражает объективную структуру предметной области
+
+### Тип возникает в практике
+
+Не задаётся сверху, а вырастает из задачи
+
+### Тип — в движении форм материи
+
+Развивается, дополняется, трансформируется
+
+### Тип — отношение форм материи
+
+Не изолирован, а связан с другими типами, с памятью, с временем
+
+### Тип — результат познания материи
+
+Чем глубже понимание — тем точнее тип. Тип — это не только ответ на вопрос "что это", но и "почему", "каким образом", "зачем".
+
+## Путь от базового к универсальному: три стадии онтологического развития
+
+### Стадия 1: Отрицание абстрактов (антипод метафизике)
+
+Мы отрицаем существование "абстрактных типов" как таковых.
+
+Нет `int` . Есть `Счёт` , `Индекс` , `Количество` , `КодОшибки` .
+
+Нет `string` . Есть `Имя` , `Хэш` , `Запрос` , `Ответ` .
+
+```prolet
+(тип Рубль или Рубля или Рублей (// синонимы типа)
+    (// Абстракция в основе типа)
+	@_база    Целое
+
+    (// Допустимый диапазон на базе абстрактного типа)   
+    @_диапазон (0 999_999_999)
+
+ 	(// Допустимые операции над конкретным типом)
+    @_операции (слож выч))      
+```
+
+::: info
+Примитив не уничтожен, но воспроизведён на новом уровне — как осмысленная категория.
+
+:::
+
+### Онтологическое уточнение: свойство `@_база Целое`
+
+Свойство `@_база` опирается на математическую абстракцию `Целое`, но по отношению к материалистичному миру является сущим *только в рамках математического дискурса*. Т.е. математические типы не ограничиваются типом `Целое`. Но этим типом ограничивает аппаратура. Аппаратный тип `Целое` обобщается таким же математическим типом с известными наложенными ограничениями.
+
+Это — *ключевое* уточнение, которое позволяет не отступать от диалектического материализма, но признать относительную самостоятельность аппаратного, равно и математического мышления как *специфической формы отражения реальности*.
+
+### Интерпретация
+
+| ПОНЯТИЕ                | СТАТУС В ОНТОЛОГИИ PROLET                                                                                                                                                                                                                                                                                                                          |
+|------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Математический дискурс | Специфическая математическая практика, в которой абстракция (вроде `Целое`) обращаются как не первичная данность, а результат высшего обобщения практики счёта (считали камни, яблоки, дни — и выделили общую форму)                                                                                                                                 |
+| Языковой дискурс       | Специфическая общественная практика, в которой абстракция `Целое` приобретает явные множественные формы (число камней, яблок, дней) с общими и частными свойствами, но контекст задаётся программистом (определяется конкретный тип).                                                                                                                |
+| Аппаратный дискурс     | Специфическая вычислительная практика, в которой произвольно смоделированный тип программистом отражается на реально существующую аппаратуру в доступной форме. В ходе изменения формы сущности теряются свойства типа, которые фактически становятся ограниченными конкретными операциями в конкретном алгоритме (переход качества в количество). |
+| @\_база                 | Указание на форму, заимствованную из математического дискурса, но используемую как инструмент для организации сущего                                                                                                                                                                                                                               |
+
+Это — далеко от платонизма, по сути это признание автономии отражения на разных уровнях бытия.
+
+Как язык отражает мир, так и аппаратура, так и математика — отражает количественные отношения, и эти отношения не существуют вне практики.
+
+📜 Принципы объявления типов `prolet`
+
+- Тип — только материализованная форма сущего
+- `Целое`,  `Строка`,  `Дробное`,  `Логическое` — не типы, а базовые абстракции
+- `@база` — не наследование, а заимствование формы из дискурса математического аппарата
+- Тип всегда имеет социальный, экономический или технический контекст
+- Без свойств, отражающих практику — *нет типа*
+- Определение вида c использованием математического типа `(тип Целое ...)` — ошибка онтологии, запрещено
+
+## Стадия 2: Сложное — как единство противоположностей
+
+Структура — не просто набор свойств, а единство противоречий:
+
+```prolet
+
+(// любой тип имеет одно значение,
+		не число свойств может быть любым)
+(тип Роль или Права
+    @_обязательно
+    @_база Перечисление
+    @_выбор_ (Админ Пользователь Гость)
+    @значение Гость (// По умолчанию, можно менять)
+    @_док "Роль пользователя в системе"
+
+(тип ПользовательНомер
+    @_обязательно
+    @_база          Целое
+    @_диапазон      (1 999_999_999)
+    @_автоИнкремент
+    @_уникально
+    @_док ( "идентификация пользователя в системе")
+
+(тип Имя или Название
+    @_база      Строка
+    @_умолчание "Иван"
+    @_док       "идентификация пользователя в системе")
+
+(структ Пользователь
+    @_номер ПользовательНомер
+    @имя  Имя (// Можно менять)
+    @счёт Счёт
+    @роль Роль
+    @если_акт Активность
+)
+```
+
+Свойство в структуре может ссылаться только на практический тип — то есть на материализованное сущее (тип или структура).
+
+Прямая ссылка на аппаратную абстракцию вне явно обозначенных границ (`Целое`, `Вещ` и т.п.) — запрещена.
+
+Все свойства в типе, помечены префиксами:
+
+- `@_база` -- системный, нельзя изменить
+- `@значение` -- пользовательский, можно изменять.
+
+В приведённом синтаксисе объявления структуры достигается единство формы и содержания:
+
+- Разделение "атрибут vs поле" — идеализм, ведущий к ложному противопоставлению "сущности" и "её свойств". В предлагаемом подходе всё является свойством. Абстракция `Целое` *должна* быть отражена на реально существующий носитель, который *неизбежно* приобретает дополнительные свойства.
+- В реальности — есть только объект с характеристиками: у человека — имя, возраст, роль, статус, история.
+- Нет "основных данных" и "метаданных" — есть все данные как единое сущее.
+
+### Философский и практический смысл
+
+|      АСПЕКТ       | ОБЪЯСНЕНИЕ                                                                                                                                                                                                                  |
+|:-----------------:|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|     Онтология     | Тип — не шаблон, а форма сущего в практике. Если в практике номер всегда уникален и присваивается автоматически, то такие свойства — часть его бытия, а не внешнее условие. Контекст не может переопределить свойство типа. |
+|  Единство формы   | Если ПользовательНомер используется в 10 структурах — не нужно 10 раз писать `@уникально`. Нарушение — на уровне типа, а не контекста.                                                                                        |
+|   Безопасность    | Система гарантирует уникальность и обязательность на уровне типа, а не доверяет типу "не забыть".                                                                                                                           |
+| Эволюция практики | Если правило изменится (например, номер перестанет быть авто-инкрементным), —  меняется одно свойство в типе, а не в конкретном контексте.                                                                                  |
+
+### Принципы проектирования в prolet
+
+- Тип несёт свои нормы: `@обязательно`, `@уникально`, `@авто-инкремент`, `@умолчание` — определяются в (тип ...)
+- Структура — композиция, а не конфигурация: она не задаёт правила, а использует уже заданные
+- Свойства в структуре — только контекстные: например, `@источник`, `@момент`, `@ответственный`, но не базовые свойства типа
+- Повторное указание свойств типа в структуре — избыточно и запрещено, но не запрещены свойства самого свойства (свойство структуры рассматривается как тип на своём уровне)
+- Тип — со всеми своими свойствами, законченная форма сущего, пригодная к использованию в любой структуре
+
+## Форма 3: типаж — тип как отношение
+
+```prolet
+(типаж Хранилище
+    @_док "Абстракция работы с хранилищем"
+	(Нов (ХранилищеИмя имя): Результат Хранилище)
+		@_док "Создаёт новое именованное хранилище"
+    (ПолучФайл (ИмяФайла имя): Результат Спис.Байт)
+        @_док "Читает файл с диска")
+    (ЗаписатьФайл (ИмяФайла  имя
+				   Спис.Байт данные): Результат Бул @мут)
+        @_док "Записывает файл на диск")
+    (ЗакрытьХранилище)
+)
+
+(Хранилище Нов "тест_хран")(уст хран)
+(хран ПолучФайл "test.txt")
+```
+
+Типаж определяется не сущностью, а связями — как в диалектике.
+
+- типаж — объявляет форму взаимодействия, а не математическую сигнатуру
+- Каждое действие — глагол, отражающий практику
+- Параметры: `(%Тип %имя %Тип %данные)` — именованные, ссылаются на типы
+- Возврат: (%Результат %Тип) — структура, отражающая результат практики
+- Возвращаемый результат может отсутствовать
+- Все типы в типаже — практические, определённые через (тип, структ, ...)
+- @\_док и др. свойства — не обязательны для каждого метода и типажа, но можно потребовать обязательность на уровне проекта или конкретного действия
+- Типаж не содержит реализации — только действия с параметрами и возвращаемые значения
+
+## Онтологическая иерархия типов
+
+::: info
+Это — спираль развития, а не лестница. Каждый новый тип — не просто добавление,  а результат борьбы и единства противоположностей.
+
+:::
+
+```mermaid
+flowchart LR
+subgraph Практика
+	direction TB
+	Субъект --> Цели
+	Цели --> Задачи
+	Задачи --> Свойства
+end
+subgraph prolet
+	direction TB
+	Типажи --> Структуры
+	Структуры --> Типы
+	Типы --> БазовыеТипы
+end
+
+subgraph СинтезАппарат
+	direction TB
+	АппаратныйТип1
+	АппаратныйТип2
+end
+
+Практика --> prolet
+prolet --> СинтезАппарат
+
+```
+
+## Практические гарантии онтологии
+
+- Нет "голых" примитивов в публичных типажах.
+- Все типажи — документированы, семантически обогащены.
+- Переход от простого к сложному — не волевой, а мотивированный практикой.
+- Форма — не обязательна, но поощряется в крупных системах.
+
+## Заключение: онтология как отражение мира
+
+- предложенная онтология отрицает метафизику примитивов,
+- Разрешает противоречие между простым и сложным,
+- Снимает противоречие в универсальной форме,
+- Делает типаж не абстрактной сущностью, а категорией бытия, движения и отношения.
+
+Это — не просто система типов, это — модель познания мира:
+
+`от чувственного (примитив)` → `к рациональному (сложное)` → `к диалектическому (универсальное)`.
+
+::: success
+Язык, построенный так, не может допустить ошибку на миллиард долларов, потому что он не позволяет мыслить иначе, чем в категориях реальности.
+
+:::

docs/docs/02_20.md

@@ -0,0 +1,202 @@
+# pro-011 Диалектика становления: абстракция - конкретное - обобщение
+
+Дерево сущностей в **prolet** представлено ниже:
+
+```mermaid
+flowchart LR
+subgraph Практика
+	direction TB
+	Субъект --> Цели
+	Цели --> Задачи
+	Задачи --> Свойства
+end
+subgraph prolet
+	direction TB
+	Типажи --> Структуры
+	Структуры --> Типы
+	Типы --> БазовыеТипы
+end
+
+subgraph СинтезАппарат
+	direction TB
+	АппаратныйТип1
+	АппаратныйТип2
+end
+
+Практика --> prolet
+prolet --> СинтезАппарат
+
+```
+
+В данном случае отображается не иерархия типов, а онтологический процесс становления, в соответствии с законами диалектического материализма:
+
+- `отрицание` → `противоположность` → `синтез`,
+- `форма` → `содержание` → `единство формы и содержания`.
+
+Разберём схему более подробно, уточним и закрепим эти положения как каноническое *отражение развития сущего* в **prolet**.
+
+## 🔍 Диалектический разбор
+
+### Практика (сущее)
+
+**Что:** существующие общественные отношения,возникающие противоречия в виде целей, определяющих задачи. Задачи ограничены конкретными условиями
+
+**Статус:** реально существующую практика, пространство противоречий и ограничений.
+
+**Роль в диалектике:** зарождение противоречия
+
+**Противоречие:**  между тем что есть, и тем что должно быть.
+
+### Свойства
+
+**Что**: `@_база`, `@_диапазон`, `@_обязательно`, `@значение`, `@активен` — характеристики сущего.
+
+**Происхождение**: сопровождают всё сущее, как внешние ограничения конкретного существования.
+
+**Роль**: Отражают состояние, статус, ограничения, контекст.
+
+**Противоречие:** определяются конкретной практикой, могут быть неприменимы к изменившемся материальным условиям, что способно привести к нарушениям логики. 
+
+✅ Свойства — не метаданные, а сущее, выделенное из конкретного контекста.
+
+### Типажи (конкретизация практики)
+
+**Что**: `Пользователь`, `Заказ`, `Документ` — формы композиции, конкретизирующие  общие формы практики.
+
+**Статус**: конкретизация практики — не просто набор действий и свойств сущностей, а более конкретная форма практики, в которой отношения между частями не на столько важны, как действия доступные группе обобщений.
+
+**Роль в диалектике**: «Синтез: не  форма организации практики, а реализация самой практики».
+
+**Противоречие:** цели формируемые субъектом определяют задачи с заданными свойствами, но не отражаются в конкретном коде. Типажи формализуют задачи и свойства и определяют дальнейшее определение структур.
+
+✅ Определяются через `(типаж ...)`.
+
+### Структуры (конкретизация формы)
+
+**Что**: `Пользователь`, `Заказ`, `Документ` — формы композиции, отражающие конкретизацию типажа.
+
+**Статус**: синтез  конкретного — не просто набор свойств, а законченная форма сущего, в которой отношения между частями — так же важны, как и сами части.
+
+**Роль в диалектике**: «Синтез: не тип, не значение, а форма организации конкретной практики».
+
+✅ Определяются через `(структ ...)`.
+
+**Противоречие:** типажи не обладают конкретной структурой сущности,только описывают поведение. Структуры позволяют реализовать описанное поведение с специфичной структурой для конкретной сущности.
+
+### Типы (сущее с формой)
+
+**Что**: `Рубль`, `ЧеловекИмя`, `ПользовательНомер`, `Роль` — материализованные формы сущего, возникшие в практике.
+
+**Статус**: типы вписаны в контекст, имеют единицы, ограничения, назначение.
+
+**Роль в диалектике**: «Противоположность идеализму — конкретное, социальное, ограниченное сущее».
+
+**Противоречие:** структура обладая частями и поведением не может описывать свои части. Тип делает именно это: описывает составную часть с заданной характеристикой
+
+✅ Определяются через `(тип ... @_база Абстракция)`.
+
+### Базовые типы (сущее, основа конкретного)
+
+**Что:** `Целое`, `Строка`, `Бул`, `Срез` — носитель практических типов, отражение аппаратных типов.
+
+**Статус:** отражение аппаратных типов в виде одной формы, носитель для конкретных типов.
+
+**Роль в диалектике:** отражение аппаратного, предоставление базы для конкретных типов.
+
+**Противоречие:** практический тип не может непосредственно быть использованным как аппаратный тип, базовый снимает конкретные ограничения на практическую реализацию.
+
+Встроены, не определяются и не переопределяются.
+
+::: info
+В **prolet** нельзя использовать напрямую — только через `@_база`.
+
+:::
+
+### Материальная база (контекст существования практики)
+
+**Что**: `Аппаратура` — новая конкретная форма аппаратуры, среда практической деятельности.
+
+**Статус**: среда конкретной реализации, пространство доступного, отрицание абстрактного.
+
+**Роль в диалектике**: «Отрицание  абстрактного».
+
+**Противоречие:** базовый тип ничего не знает о возможностях аппаратуры. С ходом развития и/или расширения языка — аппаратура наиболее полно реализует возможности языка.
+
+## Действия и типажи
+
+**Действия**: действия, применяемые к структурам — `ПроверитьАктивность`, `ОтправитьЧерезПочту`.
+
+**Типажи**: конкретизация практики, отражающее форму взаимодействия с сущим, независимо от реализации.
+
+::: info
+Типажи — не "сверху", а "конкретизация практики": они возникают как ограничение практики, как контекст.
+
+:::
+
+✅ Таким образом:
+
+- Практика порождает типажи
+- Структуры конкретизируют типажи,
+- Действия реализуются в структурах,
+
+🔄 Полная диалектическая цепочка
+
+```mermaid
+flowchart LR
+subgraph Практика
+	direction TB
+	Субъект --> Цели
+	Цели --> Задачи
+	Задачи --> Свойства
+end
+subgraph prolet
+	direction TB
+	Типажи --> Структуры
+	Структуры --> Типы
+	Типы --> БазовыеТипы
+end
+
+subgraph СинтезАппарат
+	direction TB
+	АппаратныйТип1
+	АппаратныйТип2
+end
+
+Практика --> prolet
+prolet --> СинтезАппарат
+```
+
+## 📜 Онтологическое содержание уровней
+
+- Свойства: `@_база`, `@активен` (Ограничения практики)
+- Типажи: `Хранилище`, `Аутентификатор` (Конкретизация форм практики)
+- Структуры: `Пользователь`, `Заказ` (Форма конкретизации типажей)
+- Действия: `ПроверитьАктивность` (Действия над сущим)
+- Типы: `Рубль`, `Роль` (Конкретизация базы)
+- Базовые типы: `Целое`, `Строка` — конвертер в аппаратные типы
+- Аппаратный тип: новый предельно конкретный минимальный тип.
+
+## 💡 Философское обоснование
+
+Идеи языка следуют диалектическому материализму:
+
+- Развитие идёт не сверху вниз, а от практики к её обобщению в высшей форме, и далее в новой форме опять к практике.
+- Типаж не первичен, он — порождение практики.
+- Базовый тип не абстрактен, но не обладает всей полнотой конкретного свойств,
+- а тип — уже вписан в практику на основе базового типа,
+- Структура — синтез конкретных типов. 
+-  «Не `interface` как божественный замысел, а `типаж` как инструмент труда, и как обобщение структур — вот путь материалистического программирования».
+
+## 🏁 Заключение
+
+Установлена онтологическая модель **prolet**:
+
+Это не иерархия типов.
+
+Это — диалектика становления сущего: `от обобщённой практики` →`к ограниченной задаче` →`к конкретной задаче` → `к предельно конкретной практике`.
+
+::: success
+**prolet** — не язык программирования.  
+Это — *язык фиксации развития практики*.
+
+:::

docs/docs/02_30.md

@@ -0,0 +1,167 @@
+# pro-012 Диалектика изменяющего и трансформирующего действия
+
+Язык, отражающий диалектически реальный мир должен явно в общей форме различать две типа контекстов: процесс и функция.
+
+Первое -- может приводить к разным результатам при одном порядке действий.
+
+Второе -- имеет всегда одно и то же завершение при одних и тех же входных данных (чистая функция).
+
+Введение чёткого онтологического различия между двумя формами действия в языке **prolet** позволяет добиться следующих диалектических эффектов:
+
+- *процесс* — *форма практики*, зависящая от материи, времени и условий, может давать разные результаты при одинаковых шагах.
+- *функция* — *форма чистого преобразования*, детерминированная, всегда дающая одинаковый результат при одинаковых входах.
+
+Это — не просто синтаксическое различие.
+
+::: info
+Это — отражение диалектики необходимости и случайности, единства и борьбы противоположностей: материи и формы, практики и логики, времени и закона.
+
+:::
+
+## ✅ Принятое положение
+
+В коде на языке **prolet** различаются два типа тэгов-действий :
+
+- `(прц ...)` — материальный процесс, зависящий от внешних условий, времени, состояния системы.
+- `(фн ...)` — чистое преобразование, не имеющее побочных эффектов, детерминированное, отвечающее критерию математической функции.
+
+## 🔁 Диалектическое различие
+
+| КАТЕГОРИЯ              | ПРОЦЕСС                                  | ФУНКЦИЯ                                  |
+|------------------------|------------------------------------------|------------------------------------------|
+| Природа                | Материальный, исторически обусловленный  | Формальный, логически детерминированный  |
+| Зависимость от времени | Да: каждый запуск — новый момент         | Нет: время не влияет                     |
+| Побочные эффекты       | Допустимы (запись, отправка, изменение)  | Запрещены                                |
+| Детерминированность    | Нет: может зависеть от шлюзов, состояния | Да: одинаковые входы → одинаковые выходы |
+| Онтологический статус  | Практика, действие, изменение            | Закон преобразования                     |
+| Аналог в реальности    | Работа завода, регистрация пользователя  | Формула: f(x) = x²                       |
+
+::: info
+Процесс — это диалектика материи в движении.  
+Функция — это закон, выделенный из практики.
+
+:::
+
+## ✅ Форма объявления: процесс
+
+```prolet
+(прц ОтправитьУведомление
+    	(Пользователь пользователь @мут
+		 Сообщение    сообщение ): Результат КодОшибки @мут(
+    (если (ПроверитьАктивность пользователь)
+        тогда ((ПодготовитьСообщение сообщение)
+				(ПолучитьПочту пользователь)
+                (ОтправитьЧерезПочту @рез)
+                (ЗаписатьЖурнал "Уведомление отправлено"))
+    ))
+)
+```
+
+### Семантика процесса
+
+Может возвращать разные результаты при одинаковых `пользователь` и `сообщение`:
+
+- почта упала,
+- email изменился,
+- пользователь деактивирован.
+
+Имеет побочные эффекты:
+
+- запись в журнал,
+- отправка.
+
+Зависит от времени и состояния системы. Параметры по умолчанию фиксированы, чтобы явно указать факт изменяемости, нужно передавать атрибут `@мут` .
+
+::: info
+Процесс — *не функция*, а *практика социального взаимодействия*.
+
+:::
+
+## ✅ Форма объявления: функция
+
+```prolet
+(фн ПолучитьКвадрат (Число x): Число(
+    (Умножить x x))
+)
+
+(фн ФорматироватьИмя 
+		(Имя     имя
+  		 Фамилия фамилия): Текст(
+    (Соединить фамилия " " имя))
+)
+```
+
+### Семантика функции
+
+- При одинаковых `x` всегда вернёт одинаковый результат.
+- Нет побочных эффектов: не пишет, не отправляет, не изменяет.
+- Не зависит от времени, состояния, внешних условий.
+- Может быть вычислена в любой момент, *даже заранее*.
+- Поскольку все параметры неизменяемы — нет смысла  указывать *@мут*, в любом случае все параметры воспринимаются как фиксированные.
+
+::: info
+Функция — чистое преобразование, заимствованное из логического дискурса, но вписанное в практику как инструмент.
+
+:::
+
+## 📜 Онтологические правила `prolet`
+
+| ПРАВИЛО | ФОРМУЛИРОВКА                                                                        |
+|---------|-------------------------------------------------------------------------------------|
+| 1       | процесс -- действие, зависящее от материи и времени, может давать разные результаты |
+| 2       | функция -- чистое преобразование, всегда одинаковый результат при одинаковых входах |
+| 3       | функция не может вызывать процесс (иначе — не чистая)                               |
+| 4       | процесс может использовать функцию (как инструмент преобразования)                  |
+| 5       | функция не имеет побочных эффектов                                                  |
+| 6       | процесс может иметь побочные эффекты (запись, отправка, изменение)                  |
+| 7       | функция может быть встроена в процесс, но не наоборот                               |
+
+## 🔄 Пример: процесс, использующий функцию
+
+```prolet
+(прц ОбновитьПрофиль (
+		Пользователь пользователь @мут 
+        Имя имя_новое 
+        Фамилия фамилия_новая): Результат(
+    (если (ПроверитьПрава пользователь)
+    тогда (
+		(ФорматироватьИмя имя_новое фамилия_новая)
+        (уст полное_имя)
+		(Пользователь.УстИмя (пользователь полное_имя)  
+        (СохранитьБаза (пользователь))
+    ))
+)
+```
+
+Здесь:
+
+- ФорматироватьИмя — функция, чистая, детерминированная.
+- СохранитьБаза — процесс, зависит от прав, состояния базы, времени.
+
+## 💡 Философское обоснование
+
+Нотация следует духу диалектического материализма:
+
+- Материя первична — процесс отражает её движение.
+- Форма вторична — функция — идеализация, выделенная из практики.
+- Но форма может служить практике — функция используется внутри процесса.
+- Но не наоборот — практика не может быть сведена к форме.
+
+## 💬 «Функция — как формула в голове инженера
+
+- Процесс — как работа завода.
+- Формула помогает управлять заводом,
+- но завод не сводится к формуле, с помощью процессов завод преобразует материю в новые формы.
+
+## 🏁 Заключение
+
+В этой части установлено ключевое онтологическое различие:
+
+- функция — закон преобразования, выделенный из практики, но не зависящий от неё.
+- процесс — реализация практики, зависящая от материи, времени, случайностей.
+
+::: success
+`prolet` больше не смешивает форму и содержание.  
+Он разделяет их — чтобы соединить на высшем уровне.
+
+:::

docs/docs/02_40.md

@@ -0,0 +1,227 @@
+# pro-013 Присвоение результатов как диалектическое отражение времени
+
+В языке программирования **prolet**, присвоение основано на стреле времени и онтологической чёткости: присвоение — не операция в стиле `x = f()`, а процесс перехода от действия к сущему,  зафиксированный как направленное преобразование во времени:
+
+`(%выражение)(уст %переменная)`
+
+Это — не синтаксический курьёз.
+
+Это — онтологическая фиксация становления:
+
+- сначала — процесс,
+- потом — сущее.
+
+::: info
+Мы живём в мире, где стрела времени всегда направлена в одну сторону. Это означает, что все процессы протекают в одном направлении — вдоль оси времени (даже если процесс обратим).
+
+:::
+
+Поэтому и синтаксис языка должен следовать реальности в духе диалектического материализма.
+
+Это — не просто замечание. Это объективное требование, чтобы язык **prolet** не просто описывал сущее, а воспроизводил в своей форме саму природу бытия: материю, движение, развитие, необратимость времени.
+
+## Отражение односторонней направленности времени
+
+- Все процессы — упорядочены по оси времени,
+- Все операции — имеют начало, развитие и результат,
+- Никакого «возврата в прошлое»,
+- Никакого «параллелизма без указания порядка»,
+- Никакого «абстрактного одновременного существования».
+
+## 🔁 Диалектика времени и языка
+
+- Время -- Одностороннее, необратимое
+- Синтаксис -- линейный, направленный
+- Процесс -- Развивается: причина → следствие
+- Код -- отражает последовательность
+- Обратимость -- Физически возможна, но всё равно идёт вперёд
+- Даже "откат" — новый процесс
+- Состояние -- Момент среза процесса. Фиксируется как сущее в момент `t`
+
+❗ Даже если система «возвращается» в предыдущее состояние — это не возврат во времени, а новый процесс, имитирующий прошлое.
+
+💬 Форма языка — не статична, а процессуальна. Как материя в движении, так и код в **prolet** — развивается во времени.
+
+## ✅ Канонический пример
+
+Код читается и выполняется слева направо, сверху вниз — как поток практики.
+
+Операции отражают движение от причины к следствию.
+
+Нельзя использовать то, чего ещё не было. Синтаксис запрещает ссылки на будущее.
+
+```prolet
+(// Фиксированный результат, мутабельность определяется в 
+	сигнатуре вызова, по необходимости можно усилить требования, 
+	но не ослабить по Бертрану Мейеру)
+(ПолучитьДанные)(уст данные)
+(ГруппироватьПо данные ключ)(уст группа)
+(СуммироватьПо данные группа)(уст результат)
+```
+
+::: info
+Нет «выражений, вычисляемых в параллель без указания порядка».
+Порядок — не подразумевается, а фиксируется.
+
+:::
+
+Разберём досконально.
+
+### 🧩 Семантическая структура присвоения
+
+Форма:
+
+```prolet
+(%выражение)(уст %имя)
+```
+
+или
+
+```prolet
+(// Если возвращает @мут -- можно усилить требования, 
+		но не ослабить)
+(Выражение)(уст имя @фикс)
+```
+
+#### Внешние скобки — единое выражение присвоения
+
+```prolet
+( ... )
+```
+
+✅ Всё — одно выражение, отражающее процесс становления.
+
+#### Внутреннее выражение — действие, порождающее сущее
+
+```prolet
+(ПолучитьДанные)
+```
+
+Это — вызов, процесс, действие во времени.
+
+Он ещё не сущее, но источник сущего.
+
+#### `уст` — стрелка времени
+
+Указывает направление:
+
+- от процесса к результату,
+- от возможного к сущему.
+
+✅ Допустимо, потому что:
+
+- однозначно,
+- отражает направленность времени,
+- не перегружено смыслами.
+
+### фикс / мут — онтологический статус переменной
+
+- `Переменная @фикс` — исторический факт, неизменяемый после присвоения
+- `Переменная @мут` — рабочая величина, допускающее последующие изменения
+
+::: info
+Это — *не тип*, а *статус существования во времени*.
+
+:::
+
+## имя — идентификатор сущего
+
+Пример: `данные`, `группа`, `результат`
+
+::: info
+Имя — *не метка* памяти, а обозначение *зафиксированного сущего*.
+
+:::
+
+## ✅ Полная семантика
+
+```prolet
+(ПолучитьДанные)(уст данные @фикс)
+(// Результат процесса 'ПолучитьДанные' становится сущим,
+именуется 'данные', и далее считается завершённым, неизменяемым фактом)
+
+(СуммироватьПо данные группа)(уст результат)
+(// Результат процесса 'СуммироватьПо' становится сущим,
+	именуется 'результат', но может быть изменён в будущем)
+```
+
+## 📜 Онтологические правила присвоения в **prolet**
+
+- Присвоение — выражение в парных скобках
+- Форма: `(выражение)(уст имя @мут)` или `(выражение)(уст имя)` без изменяемости
+- `@фикс` — создаёт факт
+- `@мут` — создаёт изменяемую величину
+- `уст` — стрела времени, отражает переход от действия к сущему
+- Нет форм `:=`, `=`, `<-`, `->` . Только `уст` как отражение реального потока времени в одну сторону
+- Нельзя использовать имя до его присвоения
+- `@фикс` нельзя переопределять;
+- `@мут` — можно, если сигнатура вызова определяет изменяетмость результата
+
+## 🔄 Пример: полный процесс
+
+```prolet
+(прц ОбработатьДанные (): Результат.Ок @фикс
+    (ПолучитьДанные)(уст данные @фикс)
+    (если (ПроверитьПусто данные)
+        тогда (вернуть Результат.Ошибка "нет_данных"))
+
+    (ГруппироватьПо данные ключ)(уст группа @фикс)
+    (СуммироватьПо группа)(уст результат)
+
+    (ДобавитьМетаданные результат)(уст результат)
+
+    (вернуть Результат.Ок результат)
+)
+```
+
+- ✅ Каждое присвоение — этап фиксации сущего.
+- ✅ `@фикс` — для завершённых фактов.
+- ✅ `@мут` — для рабочих величин, допускающих развитие.
+
+## 💡 Философское обоснование
+
+Язык **prolet** следует диалектическому материализму:
+
+- Сущее не дано сразу — оно становится через процесс.
+- Присвоение — не копирование, а онтологическое рождение.
+- Стрелка `уст` — не оператор, а символ времени, отражающий: 
+  - «сначала было действие,
+  - потом — результат,
+  - потом — имя».
+
+::: info
+«Как пролетариат не становится классом сам по себе, а только в ходе развития классовых противоречий, через осознание себя общественной силой, так и значение не становится сущим без фиксации».
+
+:::
+
+## 🏁 Заключение
+
+Язык установил онтологически чистую форму присвоения:
+
+**prolet** — не язык программирования, а язык фиксации процесса во времени.
+
+- Он не абстрагируется от времени.
+- Он воспроизводит его в синтаксисе.
+- Стрела времени — не метафора. Она — структура языка.
+
+`(действие)(уст имя @фикс)` — это не присваивание, это — акт фиксации сущего во времени.
+
+Нет места для `x = f()`. Есть только `(f)(уст x)` — как протокол становления.
+
+- Время — объективная форма существования материи.
+- Никакого «вневременного» существования типов, функций, значений.
+- Каждое сущее — момент процесса.
+- Язык — не зеркало, а отражение, в котором форма подчинена содержанию.
+
+::: success
+«Код в prolet — не набор инструкций, а запись практики, зафиксированной в единстве материи и движения».
+
+:::
+
+Описанная семантика **вводит в язык диалектику бытия и становления**:
+
+> **Каждое присваивание — это момент в истории системы,**  
+> **и эта история не может быть стёрта, она может только изменить форму бытия.**
+
+Это — язык не для «вычисления», а для **практического преобразования мира**.  
+Именно такой язык нужен для построения **надёжных, осознанных, этичных систем**.

docs/docs/02_50.md

@@ -0,0 +1,201 @@
+# pro-014 **Виртуальная машина как орудие материальной практики**
+
+Ниже следуют рассуждения о сущности виртуальной машины для диалектического языка, которая должна соответствующим образом транслировать все контексты на уровень исполнения. Такая виртуальная машина, которая снимает противоречие различных аппаратных архитектур. Какими свойствами должна обладать такая виртуальная машина чтобы язык **prolet** мог перенести на неё свои возможности без потери смыслов?
+
+Виртуальная машина передаёт воздействие орудия труда на предмет труда, границу между языком как инструментом описания реальности и машиной реализующей это описание реальности, в диалектике конкретного.
+
+Какова должна быть виртуальная машина (**ВМ**), чтобы диалектически воплощать **prolet** в железе?
+
+Ответ — не технический, а философско-материалистический:
+
+**IL** для **ВМ** (и сама **ВМ**) в такой постановке вопроса неизбежен, но не как технический костыль, а как необходимый этап изменения мира для развития вычислительной формы и приведение её в действие.
+
+## Зачем IL? Диалектическое обоснование промежуточного языка для ВМ
+
+Противоречие: `язык` vs `аппаратура`
+
+- Язык **prolet** — отражает реальность, человекоцентричный, диалектический.
+- Аппаратура — синтетическая, конкретная, разнородная, ограниченная.
+
+Без посредника, трансформирующего переход от широкого к конкретному — нет единства, нет перехода от формы описания к форме действия.
+
+Решение: **IL** как продолжение языка и переход к железу
+
+- **IL** не есть **prolet**, но порождён им.
+- **IL** не есть машинный код, но ведёт к нему.
+
+Он — синтез:
+
+- преобразует непосредственность языка,
+- обобщает разнородность железа,
+- и приводит к *исполняемому процессу*.
+
+Это — переход от описания к действию:
+
+**prolet** (как инструмент) → IL (форма-посредник) → машинный код (исполнение) → но на новом уровне — с сохранением смысла **prolet**.
+
+## Свойства IL: диалектический промежуточный язык
+
+**IL** должен быть не просто набором инструкций, а отражением онтологии **prolet** иными средствами, от материалистического описания к практическому действию.
+
+## Принципы построения IL
+
+### Соответствие атомарным контекстам
+
+Каждый атомарный контекст имеет однозначное, минимальное отражение в **IL**
+
+### Неделимость
+
+**IL**-инструкции — атомарны в рамках контекста **ВМ**, не могут быть прерваны
+
+### Объективность
+
+**IL** *не зависит* от архитектуры, ОС, компилятора
+
+### Развиваемость
+
+**IL** может расширяться, но только через синтез атомарных контекстов, а не хаос интегрированного движения
+
+### Читаемость
+
+**IL** должен быть понятен человеку — как чертёж завода
+
+### Педагогичность
+
+По **IL** можно понять, как работает **prolet**
+
+### Отображение атомарных контекстов в IL
+
+Каждый контекст **prolet** → одна или несколько **IL**-инструкций,
+но без потери смысла.
+
+`(асм (...))`
+
+```prolet
+(асм 
+	(сохр x стек)
+	(// Поместить значение в стек)
+
+	(// Прямое сравнение с константой)
+	(сравнить рег0 == 10)	
+
+	(// Переход по условию на метку)
+	(ЕслиНе рег0 ноль То метка1)
+
+	(// Порядок инструкций — порядок времени)
+	(рег0 уст 45)
+	(сохр рег0 n)(// Регистр ничего не знает про память)
+	(загр v рег0)(// Про памят ьи регистр знает декодер команд)
+
+	(// Организация стекового кадра)
+	(вызов прц1)
+	(адр прц1 сохр стек)
+	(вызов прц2)
+	(извл стек рег0)(// Извлечение результат)
+	(влож рег0 стек)(// Помещение результат)
+
+	(// Передача управления)
+	(авария 4)
+	(вектор рег0) (// Маскируемое прерывание)
+)
+```
+
+**IL** — не потеря смысла, а его трансляция в форму, пригодную для машинной практики.
+
+## Виртуальная машина: диалектический посредник
+
+**ВМ** — не имитация, не "виртуальность" в идеалистическом смысле, а материальная система, созданная человеком, чтобы преодолеть противоречие между разными формами бытия железа.
+
+Диалектические задачи **ВМ** -- снять  противоречие между:
+
+- аппаратными платформами x86, ARM, RISC-V,
+- различными ОС: Windows, Linux, мобильные ОС,
+- стековыми и регистровыми архитектурами,
+- эффективное исполнение на синтетической аппаратуре.
+
+## Свойства виртуальной машины (с точки зрения диалектического материализма)
+
+### Единство и борьба форм
+
+Поддерживает множество архитектур, но через единую модель исполнения
+
+### Материальность
+
+ВМ — не абстракция, а процесс в памяти и на процессоре
+
+### Первичность IL, вторичность машинного кода
+
+**IL** — отражение описания процессов, машинный код — его материализация
+
+### Развивающийся интерфейс
+
+Новые инструкции **IL** добавляются не по воле, а по необходимости практики
+
+### Контроль над памятью
+
+Реализует принципы владения **prolet**: нет случайного доступа
+
+### Время как ресурс
+
+Поддерживает точный учёт времени выполнения — как в диалектике, развитие — через время
+
+### Ошибки как объективные сигналы
+
+Не маскирует сбои, а фиксируют как объективные несоответствия между действием и условиями его выполнения.
+
+### Архитектура ВМ: смешанная регистровая стековая машина с контролем
+
+Выбор смешанной модели — не потому что она "популярна", а потому что она диалектически отражает структуру **prolet**:
+
+- Стек вызовов — отражает иерархию процессов.
+- Стек значений — отражает последовательность вычислений.
+- Локальные переменные — привязаны к кадру, как в `(знач)(уст переменная)`
+- Контроль потока — через метки и переходы, как в `(если ...)` 
+- Регистры, как необходимость эффективного исполнения
+
+```prolet
+(асм
+	(адр х стек)(// На стэк отправить ссылку на х)
+	(влож рег0 стек) (// На стэк значение регистра)
+	(влож у стек)(// На стэк содержимое значения)
+	(извл стек рег0)(// Со стека -- значение рег0)
+	(извл стек _)(// Вытолкнуть с стека)
+	(извл стек х)(// Со стека -- значение х)
+	(слож рег1 рег0)(// Сложить рег1 и рег0 с результатом в рег0)
+	(возврат) (// Возврат из функции)
+)
+```
+
+::: info
+Это — не ассемблер, это — чертёж диалектического процесса, выраженный иными средствами.
+
+:::
+
+## ВМ как способ решения противоречий процессов в мире вычислений
+
+ВМ — не анархия, а организованная система:
+
+- Контроль доступа к памяти — как контроль доступа в кооперативной среде: никто не может трогать чужую память без разрешения.
+- Учёт всех видов ресурсов — время, память, энергия.
+- Обеспечение контроля — потоки исполняются по предсказуемым правилам.
+- Поддержка развития — через обновление **IL**, но с сохранением обратной совместимости.
+
+Это — не идеалистическая "свобода", где текущий процесс эксплуатирует ресурсы процесса-неудачника, это — плановая экономика вычислений.
+
+## Заключение: **IL** и **ВМ** как диалектический мост
+
+**prolet** требует в виде среды действия **IL** и **ВМ**, но не как технические утилиты, а как необходимые формы развития:
+
+- **IL** — другая форма представления **prolet**, пригодная для практического применения,
+- **ВМ** —  материальный инструмент, позволяющий разработчику реализовать замысел в железе.
+
+Это — не идеализм, это — единство смысла и действия, где:
+
+- Смысл не теряется,
+- Реальность не игнорируется,
+- Развитие обеспечивается.
+
+::: success
+**ВМ** — обеспечивает предсказуемое распределение ресурсов на основе правил, заданных практикой, воплощая в результате труда  его производительные силы.
+
+:::

docs/docs/02_60.md

@@ -0,0 +1,200 @@
+# pro-015 Диалектика статических обобщённых типов
+
+Руководствуясь принципами диалектического материализма необходимо признать, что в реальном мире могут существовать только те типы, которые отражают эту реальность. Если один из типов существует фактически в качестве типа процессора или ВМ -- именно он должен являться базовым по отношению ко всем обобщённым типам.
+
+В синтезированной **ВМ** `prolet` базовым типом выбрано знаковое целое, потому что оно наилучшим образом отражает задачи, стоящие перед разработчиком в составе коллектива в текущих условиях.
+
+Таким образом провозглашён онтологический принцип:
+
+::: info
+`Целое` — форма, используемая в практике вычислительных процессов **ВМ**.
+
+:::
+
+Это — не компромисс, не инженерная хитрость в духе `ad hoc`, а логический шаг в построении онтологии **prolet**, где любой тип отображается в одном типе **ВМ** , а многообразие — из одного и реально существующего.
+
+Разберём это решение в свете диалектического материализма.
+
+## Зачем именно знаковое целое? Онтологическое обоснование
+
+- Принцип: `количество — первая форма бытия`
+- В диалектике качество возникает из количества.
+- Прежде чем различать "истина/ложь", "литера", "адрес" — мир различает "сколько?".
+
+Целое — форма дискретного приближения в условиях цифровой вычислительной техники, способная отражать объективные состояния:
+
+- температура,
+- счёт,
+- индекс,
+- время,
+- ошибка (код),
+- адрес памяти (в относительной форме).
+
+Оно — не абстракция, а отражение закона измерения в природе.
+
+## Почему именно знаковое?
+
+Потому что реальный мир — не только "больше нуля". Разработчик определяет разные типы величин:
+
+- Температура может быть −273°C,
+- Баланс — отрицательным,
+- Ошибка — кодом `−1`.
+
+Беззнаковое — это усложнение выражения счёта в ВМ,  которое влечёт за собой  усложнение процедур счёта, а диалектика — основана на отрицании.
+
+Знаковое целое — отражает  опыт практики, и потому — диалектически полно.
+
+## Производные типы: снятие противоречия через практику
+
+В **prolet** отказ от "независимых" типов носит методический характер.
+
+Вместо куста чудесным образом возникающих базовых типов — все базовые типы порождаются от целого, но не механически, а через ограничение и интерпретацию.
+
+### Булево
+
+форма, используемая в практике логических суждений, представлено целым (выбор из множества [0, не 0])
+
+### Литера
+
+форма, используемая в практике обозначения печатных символов. Целое (интерпретация Юникода, диапазон [0x00, 0x10FFFF])
+
+### Беззнаковое
+
+не свойство целого, а отражение социального требования:  
+„счётчик не может быть отрицательным“ `@диапазон (0, ЦелоеМакс)`
+
+Это — не упрощение, это — ограничение через свойства:
+
+- Простое (целое) — утверждается,
+- Сложное (булево, литера) — конкретизирует его,
+- Но затем — редуцируется само,
+- И возвращается как интерпретация целого в заданном контексте.
+
+## Реализация в prolet: типы как категории практики
+
+### Тип Целое 
+
+```prolet
+(тип Яблоки : Целое)
+```
+
+Целое не определяется через какой-то другой тип. В синтезированной ВМ `prolet` целое принимается в качестве базовой формы представления, поскольку она наилучшим образом отражает практику измерения и счёта в текущих условиях. Все допустимые операции — определены на нём напрямую.
+
+### Булево как ограниченное целое
+
+```prolet
+(тип Булево : Целое
+    @перечисл [Ложь, Истина]
+    @интерпретация (0 → Ложь, не 0 → Истина)
+```
+
+Использование:
+
+```prolet
+((Бул 5) -> @фикс еслиВкл)( // значение  Истина)
+(если еслиВкл
+    тогда (Напечатать "ВКЛ"))
+```
+
+При этом:
+
+- В памяти — просто не 0,
+- Но в контексте условия — интерпретируется как `Истина`.
+
+## Литера как целое с семантикой кода UTF-8
+
+```prolet
+
+(тип Литера : Целое
+    @диапазон (0 0x10FFFF)
+    @интерпретация Юникод
+    @литералы ('a' .. 'я')
+
+(Лит 'А')(уст литА)(// литера с кодом 1040)
+```
+
+Литера — не "отдельный тип", а целое, наделённое смыслом с помощью ограничивающих свойств.
+
+### Беззнаковое — как контракт, а не тип
+
+```prolet
+
+(тип Абс (// Абсолютное значение целого)
+	(// проверяется на этапе компиляции или рантайме)
+    @диапазон (0 ЦелМакс)
+)
+```
+
+Или — через валидатор:
+
+```prolet
+(фн Беззнаковый (Битность имя): Результат.Бул(
+    (ПроверитьБезЗнак имя))
+)
+
+(Беззнаковый U32)(// Проверяет беззнаковое число в рантайме
+```
+
+Беззнаковое — не база, а производная категория, возникающая в практике индексации, адресации, счётчиков.
+
+## Преимущества подхода
+
+- Минимализм онтологии
+- Один базовый тип — меньше путаницы, меньше ошибок
+- Единство представления
+- Все *атомарные* данные в **ВМ** представлены целыми, но их интерпретация определяется социальным контекстом через свойства
+- Безопасность через контекст
+- Ошибка "сложить символ и булево" — на уровне типов, при помощи  свойств
+- Развиваемость
+
+Новые типы — добавляются, но через вывод из целого как часть практики
+
+## Экономия мыслетоплива
+
+Программист не думает: "это `int` или `uint`?", а думает: "это счётчик, значит — неотрицательное"
+
+## Психологическая и педагогическая выгода
+
+- Новичок учит один тип — целое, а потом — как его интерпретировать.
+- Ошибки вроде `i = -1`; `for (i < n; ...)` — обнаруживаются по типу, и по нарушению контракта `(@диапазон (0 .. ∞)`.
+- Система подсказывает: "Переменная `i` помечена как беззнаковая, но присваивается `-1`. Это противоречит контракту."
+
+Это — не бюрократия, это — диалектическое воспитание сознания.
+
+## Диалектическая природа целого: от количества к качеству
+
+Целое — не конец пути, а начало познания.
+
+### Количество
+
+`x = 42`
+
+### Простое накопление
+
+Ограничение: `@x (0 .. 100)`
+
+### Единство и борьба (ограничение свободы ради смысла)
+
+- Интерпретация `x` как возраст, код ошибки, символ
+- Переход количества в качество
+- Синтез: `ЕслиНечто нечто как Пользователь`
+
+`Целое` становится частью сложного процесса
+
+`Целое` — не "вещь", оно — форма движения материи в пространстве значений.
+
+## Заключение: целое как первооснова prolet
+
+Приведённое решение — не просто техническое, оно — философское, революционное, диалектически зрелое.
+
+::: success
+`Целое` — не универсальная сущность, а **материальное условие, принятое в синтезированной ВМ** `prolet` для отражения практики счёта, измерения и индексации.  
+Все прочие типы — не его «производные» в метафизическом смысле, а **формы его интерпретации в конкретных социальных контекстах**
+
+:::
+
+Все прочие типы — *не равноправны*,
+
+- они — его отражённые формы,
+- его социальные ограничения,
+- его контексты для построения пространства смыслов.

docs/docs/02_80.md

@@ -0,0 +1,96 @@
+# pro-017 Контексты вычислений
+
+Ранее контексты встречались в примерах кода **prolet:** макросы**,** функции, типажи и процессы. Теперь контексты будут обозначены явно, как тип вычислительных групп.
+
+::: info
+В `prolet` больше нет «меток» или «аннотаций», висящих в воздухе.  
+Есть **контекст** — **материальная и логическая среда**, в которой возможны определённые **действия**.
+
+:::
+
+---
+
+### Почему «контекст» — правильное понятие
+
+1. **Философски**  
+   Контекст — это **условие возможности действия**.  
+   Без контекста нет смысла, нет метода, нет преобразования.  
+   Это **материалистическая категория**: действие невозможно вне условий его осуществления.
+2. **Практически**  
+   Когда программист пишет:
+
+   ```prolet
+   (Пользователь СтатусОбновить "онлайн")
+   ```
+
+   — программист не просто «вызываете метод у типа», а **входит в контекст** `Пользователь`, где определены действия:
+
+   \- `СтатусОбновить`,
+
+   \- `Сохранить`,
+
+   \- `Удалить` и т.д.
+3.   
+   Вне этого контекста — эти действия **недопустимы**.
+4. **Архитектурно**
+   - Компилятор может **ограничить доступные действия** строго по текущему контексту.
+   - IDE — показывать только валидные методы.
+   - Безопасность — запрещать вызовы, не принадлежащие контексту.
+5. **Отказ от идеализма «универсальных функций»**  
+   В `prolet` нет «голых функций», применимых везде.  
+   Есть **действия, привязанные к контексту** — как в реальном мире:  
+   - «писать» — в контексте «автор»,  
+   - «лечить» — в контексте «врач»,  
+   - «шифровать» — в контексте «Ключ» или «Сообщение».
+
+---
+
+### Примеры
+
+```prolet
+(Сообщение Шифровать ключ)
+(Ключ Применить сообщение)
+(БазаДанных Сохранить запись)
+(Запись Удалить номер)
+```
+
+Здесь:
+
+- `Сообщение` — не тип, а **контекст, в котором возможно действие** `Шифровать`,
+- `Ключ` — **контекст, в котором можно** `Применить` что-то,
+- попытка написать `(Ключ Шифровать ...)` — **ошибка**, потому что действие `Шифровать` не принадлежит контексту `Ключ`.
+
+---
+
+### Связь с @`рез`
+
+Когда программист пишет:
+
+```prolet
+(СоздатьПользователя "Алексей")
+(Пользователь СтатусОбновить @рез "онлайн")
+```
+
+— первое выражение даёт  `@рез`  типа `Пользователь`,  
+— второе выражение **входит в контекст** `Пользователь`,  
+— и только в этом контексте разрешено действие `СтатусОбновить`.
+
+Это — **естественная цепочка: результат → контекст → действие**.
+
+---
+
+### Вывод
+
+В **prolet** не существует технократического «тег», есть **философски и практически насыщенное** понятие **«контекст»**.
+
+`prolet` — это не язык с аннотациями, а **язык практики**, где:
+
+::: success
+**Каждое действие возможно только в своём контексте,**  
+**и контекст определяется материей, а не формой.**
+
+:::
+
+Это соответствует духу диалектического материализма и делает язык **ориентированным не на объекты, а на условия их преобразования**.
+
+**prolet** поддерживает абстракции, но как  **инструмент** освобождает от абстрактного мышления, которое не происходит из практики.

docs/docs/02_90.md

@@ -0,0 +1,35 @@
+# pro-018 Ассемблер prolet
+
+Ассемблер **prolet** является изолированным контекстом. В нём нет высокоуровневых типов, структур, срезов, типажей и т.п. Ассемблер выражает все доступные возможности **ВМ.** 
+
+::: warn
+Работа с виртуальной машиной на уровне ассемблера может легко испортить её состояние!
+
+:::
+
+## Контекст ассемблера
+
+Для вхождения в контекст ассемблера необходимо его активировать в форме:
+
+```prolet
+(асм
+	(...)
+)
+```
+
+После этого, все возможности декодера команд ассемблера будут доступны на этом уровне, без какой либо необходимости упоминания ассемблера. При этом все остальные возможности языка будут изолированы. На уровне ассемблера недоступны свойства ,влияющие на работу **ВМ**. Доступны системные свойства, такие как `@_док`, которые фактически никак не влияют на состояние **ВМ.**
+
+## Набор команд ассемблера
+
+Набор команд может со временем расширяться. Существующие команды меняться не будут в рамках текущей мажорной версии **ВМ**. Ограничений на расширение команд не заложено.
+
+## Макросы на уровне ассемблера
+
+Поскольку макросы в **prolet** не являются полными по Тьюрингу, а служат средством автоматизации, то макросы на уровне ассемблера разрешены. С помощью них можно удобно группировать несколько ассемблерных инструкций.
+
+## Заключение
+
+::: success
+**prolet** включает в себя ассемблер как машину исполнения. Ассемблер не содержит смыслов, не знает ничего о структурах — это машина исполнения простейших команд и хранения состояния.
+
+:::

docs/docs/03_10.md

@@ -0,0 +1 @@
+# pro-019 Набор команд ассемблера prolet

docs/pro_readme.md

@@ -0,0 +1,42 @@
+# prolet
+
+Язык программирования в духе диалектического материализма
+
+## Документация
+
+> Мы создаём язык не для себя. Мы создаём его для тех, кто придёт после.
+> Чтобы они не тратили годы на отладку того, что можно было предотвратить.
+> Чтобы они строили будущее — а не чинили прошлое.
+> Чтобы технологии служили человеку — а не превращали его в винтик.
+> Чтобы хорошее не отбрасывалось, а плохое — не принималось.
+> Чтобы время — самый ценный ресурс — тратилось на творчество, а не на борьбу с инструментом.
+
+- phi.00_10 [Философия в проектировании языков](./docs/00_10.md)
+- phi.00_20 [Отрицание эклектики в построении языка](./docs/00_20.md)
+- pro.01_10 [Контекст создания нового языка](./docs/01_10.md)
+- pro.01_20 [Диалектико-теоретические требования к языку](./docs/01_20.md)
+- pro.01_30 [Разрешение диалектических противоречий на новом уровне](./docs/01_30.md)
+- pro.01_40 [Многоэтажность языка](./docs/01_40.md)
+- pro.01_50 [Диалектика стиля нотации](./docs/01_50.md)
+- pro.01_55 [Диалектика формы языка программирования](./docs/01_55.md)
+- pro.01_60 [Диалектическое развитие S-выражений](./docs/01_60.md)
+- pro.01_70 [Диалектика развития языка](./docs/01_70.md)
+- pro.01_80 [Диалектика динамики типов](./docs/01_80.md)
+- pro.01_90 [Диалектическая несостоятельность nil](./docs/01_90.md)
+- pro.02_10 [Диалектическая онтология типов](./docs/02_10.md)
+- pro.02_20 [Диалектика становления](./docs/02_20.md)
+- pro.02_30 [Диалектика изменяющего и трансформирующего действия](./docs/02_30.md)
+- pro.02_40 [Присвоение результатов как диалектическое отражение времени](./docs/02_40.md)
+- pro.02_50 [Виртуальная машина как орудие материальной практики](./docs/02_50.md)
+- pro.02_60 [Диалектика статических обобщённых типов](./docs/02_60.md)
+- pro.02_70 [Работа с сущностями в логике диалектического материализма](./docs/02_70.md)
+- pro.02_80 [Контексты вычислений](./docs/02_80.md)
+- pro.02_90 [Ассемблер prolet](./docs/02_90.md)
+- pro.03_10 [Набор команд ассемблера](./docs/03_10.md)
+- Атомы языка
+- ВМ
+- Система типов
+
+## Лицензия
+
+Язык распространяется под лицензией [UCL](https://gitp78su.ipnodns.ru/svi/ucl).