Уточнение семантики

docs/prolet-003.md

@@ -33,20 +33,20 @@
 Пример:
 
 ```prolet
-(прц ОбработатьДанные (данные @мут Список.Байт) -> @фикс Список.Байт
+(прц ОбработатьДанные (СписокБайт данные @мут) -> Список.Байт @фикс
     (// высокоуровневая композиция)
     (ФильтроватьДанные х по данные
             (Сравнить х > 10)
-            (ФнКвадрат х))
+            (ФнКвадрат _рез))
 )
 ```
 
 ```prolet
 (// при необходимости — ручное управление)
-(прц КопироватьПамять @система (источник Сис.Адр
-                                цель Сис.Адр
-                                фикс размер Сис.Размер)
-    (Асм.ПовторОтДо рег0 рег1 ")
+(прц КопироватьПамять @система (Сис.Адр источник
+                                Сис.Адр цель
+                                Сис.Размер размер @фикс)
+    (асм ПовторОтДо рег0 рег1 ")
 )
 ```
 
@@ -88,13 +88,17 @@
 - С обязательным тестированием.
 
 ```prolet
-(фн СложитьДист1 (a @фикс Км b @фикс М)-> @фикс Км (
+(фн СложитьДист1 (
+        Км a @фикс
+        М  b @фикс)-> Км @фикс(
     (СложитьКмМ a b))
 )
 
-(прц ЗначПоАдр @система @обоснование "взаимодействие с драйвером"
-            (адр @фикс Адр) -> @фикс Адр) (
-    (ЗначИз адр)
+(прц ЗначПоАдр
+        @система
+        @обоснование "взаимодействие с драйвером"
+        (Адр адр @фикс) -> Адр @фикс (
+    (ЗначИз адр))
 )
 ```
 
@@ -176,15 +180,16 @@
 ```prolet
 (// тип выведен: Целое;
     определение @фикс -- определяется на стороне вызова)
-((Рубль 42) -> х)
+(уст (Рубль 42) х)
 
 (// явная динамика — только при необходимости,
     атрибут @возможно -- определяется на стороне вызова)
-((ПолучитьИзВнешнегоАпи) -> данные)
+(уст (ПолучитьИзВнешнегоАпи) данные)
 
 (// но в блоке безопасности — только статика)
-(фн ПроверитьДоступ @строго
-    (пользователь @фикс Пользователь роль @фикс Роль) -> @фикс ЕслиОк (
+(фн ПроверитьДоступ @строго(
+        Пользователь пользователь @фикс
+        Роль         роль         @фикс ) -> ЕслиОк @фикс(
     (// динамические типы запрещены здесь))
 )
 ```

docs/prolet-004.md

@@ -54,7 +54,7 @@
 Вариант 1: Явный блок низкоуровневый с контекстным предупреждением
 
 ```prolet
-(фн ОбработатьДанные (вход @мут Список.Байт) -> Список.Байт (
+(фн ОбработатьДанные (Список.Байт вход @мут) -> Список.Байт (
     (// Высокий уровень — чисто, безопасно)
     (ФильтрПо вход
         (x > 10)
@@ -63,13 +63,15 @@
 )
 
 (// Внимание! Здесь действуют другие законы)
-(фн СкопироватьПамять @система @прог_уровень 3 @одобрение-нужно
-    (источник @фикс Байт
-    цель @мут Байт
-    длина @фикс СбщДлина) (
+(фн СкопироватьПамять @система
+        @прог_уровень 3
+        @одобрение_нужно
+        (Байт     источник @фикс
+         Байт     цель     @мут
+         СбщДлина длина    @фикс ) (
     (ЦиклПо для i от 0 до длина
         (// Прямое обращение к памяти)
-        (Асм.Загр i рег0))
+        (асм рег0.загр i))
     )
 )
 ```
@@ -90,14 +92,15 @@
 
 ```prolet
 (модуль БезопаснаяОбработка (
-    (фн Фильтровать(данные @мут ДанныеПоток) -> @фикс ДанныеПоток (
-        если (Сравнить данные.Длина > 10)
+    (фн Фильтровать(ДанныеПоток данные @мут ) -> ДанныеПоток @фикс (
+        если (Сравнить данные @длина > 10)
         тогда (ДобСписок данные))
     )
 )
 
 (// Только для программистов с уровнем >= 3, старший инженер)
-(модуль НизкоуровневаяОптимизация @мод_уровень 4
+(модуль НизкоуровневаяОптимизация
+    @мод_уровень 4
     (импорт
         Ядро.Память
         Ядро.Асм)
@@ -130,15 +133,15 @@
 
 ```prolet
 (прц ОбработатьГруппу @уровень_ниже(
-    ((ПолучитьДанные) -> @фикс данные)
+    ((ПолучитьДанные) -> данные @фикс)
     (// Высокий уровень)
-    ((ГруппироватьПо данные (данные.ключ)) -> группа)
-    ((СуммироватьПо данные (группа)) -> результат)
+    (уст (ГруппироватьПо данные (данные @ключ)) группа)
+    (уст (СуммироватьПо данные (группа)) результат)
 
     (// Спуск в низкий уровень — через ключевое слово и атрибут)
         (// Теперь можно использовать указатели, asm)
-        (Асм.Сохр рег0 результат)
-        (Асм.Инк рег0)
+        (асм (рег0 cохр) результат)
+        (асм (рег0 инк))
 
     (// Подъём автоматически))
 )
@@ -162,7 +165,7 @@
 
 ```prolet
 (прц ОбработатьПамять @система(
-    ((ВыделитьПамять(размер @фикс Срез.Байт)) -> @конст адр)
+    ((ВыделитьПамять(Срез.Байт размер @фикс)) -> асм.адр @конст)
     (// Компилятор замечает:  "Вы используете сырые указатели")
         если (Сравнить уровень < 3)
         тогда (ПройтиМодуль "Управление памятью (5 мин)")

docs/prolet-005-01.md

@@ -72,16 +72,16 @@
 ### Вычисление
 
 ```prolet
-(фн CложитьКм (a Км b Км) -> @фикс Км
+(фн CложитьКм (Км a Км b) -> Км @фикс
     (Слож a b))
 ```
 
-## Определение типа
+## Определение структуры
 
 ```prolet
-(тип Пользователь (
-    имя Имя
-    возраст Возраст))
+(структ Пользователь
+    @имя     Имя
+    @возраст Возраст)
 ```
 
 ## Условие
@@ -95,7 +95,7 @@
 
 ```prolet
 (для x в Данные
-    ((Удвоить х) -> @фикс результат)
+    (уст (Удвоить х) результат @фикс)
     (ОтправитьПоПочте результат))
 ```
 

docs/prolet-005.md

@@ -245,9 +245,9 @@ unsafe, система владения как основы материалис
 )
 
 (// Использование:)
-(асинхронно (@данные Список.Байт)(
-    (// Внутри вызова: определение @возможно @фикс)
-    ((ОжидатьЗапрос) -> данные)
+(асинхронно (данные Список.Байт)(
+    (// Внутри вызова: определение "нечто @фикс")
+    (уст (ОжидатьЗапрос) данные)
     (ОбработатьДанные))
 )
 ```

docs/prolet-006.md

@@ -58,7 +58,7 @@
 
 ```prolet
 (фн Копировать  @система(ист @фикс Cис.Адрес цель @фикс Cис.Адрес размер @конст Дом)
-  (Асм.ПовторОтДо ист цель))
+  (асм ПовторОтДо ист цель))
 ```
 
 ### Структура данных
@@ -107,7 +107,7 @@
 Нет доступа к:
 
 - (@система),
-- (Асм),
+- (асм),
 - (макро).
 
 ```prolet
@@ -172,12 +172,13 @@
 (выраж ...)
 (тип Проверятор)
 (Список Цел 1 2 3)
-((ПользовательНов @имя "Анна"
-    @возраст 28
-    @роль Админ) -> @мут посетитель)
+(структ ПользовательНов
+  @имя "Анна"
+  @возраст 28
+  @роль Админ)
 (знач ...) или (= ...)
 (<ИмяФункции>)
-(ЕслИнтерфейс посетитель как ИФайл)
+(ЕслНечто нечто как ИФайл)
 ```
 
 Это — диалектическая гибкость: форма одна, но смысл возникает в практике применения, а не в синтаксической избыточности.

docs/prolet-008.md

@@ -76,16 +76,17 @@
 Шлюз не всегда требуется при обмене с внешним миром. Если приём данных из внешнего источника из экосистемы `prolet` -- тогда такой поток байтовых данных будет сопровождаться метками типа. В этой ситуации шлюз не нужен.
 
 ```prolet
-(// Внутри — следует использовать байтовый поток, атрибут на выходе -- @возможно)
+(// Внутри — следует использовать байтовый поток, атрибут на выходе -- `нечто`)
 ((ВебЗапросить "/data"
     @шлюз_вход
-    @требует_ревью) -> данные)
+    @требует_ревью) -> нечто)
 (// тип: фиксированный срез байтов)
 
 (// Обратный переход — только через проверку)
- (если (ПроверитьФорму данные как Структ.Пользователь)
-    тогда (ОбработатьПользователя данные)
-    иначе (ПечатьОшибка "неверный формат"))
+ (ЕслиНечто нечто как Структ.Пользователь
+    тогда (уст (Привести нечто к Пользователь) пользователь)
+    иначе (ПечатьОшибка "неверный формат")
+)
 ```
 
 Особенности шлюза:
@@ -119,12 +120,13 @@
 
 ```prolet
 (// по умолчанию статичность на выходе @фикс, параметр контакта с внешним миром -- @шлюз_вход)
-((ПолучитьИзApi) -> x)
+(уст (ПолучитьИзApi) x)
 
 (// Ошибка: (x + 1) — запрещено)
-(ЕслиТип x как Целое
-    тогда (ОбработатьЧисло (ТипКонверт Целое в x))
-    иначе (ПечатьОшибка "ожидалось число"))
+(ЕслиНечто x как Целое
+    тогда (ОбработатьЧисло (Привести x в Целое))
+    иначе (ПечатьОшибка "ожидалось число")
+)
 ```
 
 Это — материалистическое требование: чтобы работать с реальностью, нужно понять её структуру.
@@ -144,12 +146,12 @@
 
 Проверка типа:
 
-- `(ЕслиТип х как Пользователь)` Булево, безопасно
+- `(ЕслиНечто х как Пользователь)` Булево, безопасно
 - Безопасное извлечение типа
 
 ```prolet
-(ЕслиТип х как Пользователь)
-    тогда (Обработать (ТипКонверт х в Пользователь))
+(ЕслиНечто х как Пользователь)
+    тогда (Обработать (Привести х в Пользователь))
     иначе (ПечатьОшибка "ожидался пользователь"))
 ```
 
@@ -160,8 +162,8 @@
 Схемная валидация для сложных форматов:
 
 ```prolet
-(ЕслиПробаИз дата к Схема.Пользователь
-    тогда ((ПривестиИз дата к Схема.Пользователь) -> х)
+(ЕслиНечто байты к Схема.Пользователь
+    тогда (уст (Привести байты в Схема.Пользователь) х)
     иначе (ПечатьОшибка "ожидалось число"))
 ```
 
@@ -182,18 +184,18 @@
 ```prolet
 (// Сначала — динамически, "ЗапросАпи" определён как @шлюх_вход, и данные как @фикс)
 ((ЗапросАпи @шлюз_вход) -> данные)
-(ЕслиПробаИз данные как Схема.ФорматV1
+(ЕслиНечто нечто как Схема.ФорматV1
         тогда ...
         иначе ...)
 
 (// Через месяц практики — выносим в структур)
 (структ ФорматV1
-  поле1 Накладная.Название
-  поле2 Список.Целое)
+  @поле1 Накладная.Название
+  @поле2 Список.Целое)
 
 (// Использование через приведение, результат определён как @фикс)
-(ЕслиТип х как ФорматV1
-    тогда ((ЧитатьИз "data/sample.json") -> конфигТекст)
+(ЕслиНечто х как ФорматV1
+    тогда (уст (ЧитатьИз "data/sample.json") конфигТекст)
 )
 ```
 
@@ -219,20 +221,20 @@
 Но если выход — в неструктурированный формат (например, `raw TCP`), то нужен обратный шлюз — `@шлюз_выход`:
 
 ```lisp
-(фн Отправить (@x Пользователь)
+(фн Отправить (x Пользователь)
     @шлюз_выход
     @цель legacy_система
    (СериализоватьБезТипов x))
 ```
 
-Это — единство и борьба: вход и выход — разные по природе, потому что мир несимметричен.
+Это — единство и борьба: вход и выход — разные по природе, потому что мир в динамике асимметричен.
 
 ## Что делает `@шлюз_вход` на уровне ВМ?
 
 При встрече `@шлюз_вход`:
 
 - Активируется режим проверки:
-- Все значения извне — являются списком байтов.
+- Все значения извне — являются срезом байт.
 - Нельзя использовать напрямую.
 
 Требуется явное приведение:
@@ -267,22 +269,22 @@
 
 ```prolet
 (// Внешний API — неизвестная структура)
-((ВебЗапросить "https://api.partner/data"
-                @шлюз_вход @возможно) -> фикс данные)
+(уст (ВебЗапросить "https://api.partner/data"
+                @шлюз_вход) нечто @фикс)
 
 (// Проверка и переход к статике)
-(ЕслиПробаИз данные как Схема.АнализДанных)
+(ЕслиНечто нечто как Схема.АнализДанных)
     тогда (
-        ((ПривестиИз данные к Схема.АнализДанных) -> отчёт @фикс)
+        (уст (Привести нечто в Схема.АнализДанных) отчёт @фикс)
         (ОтправитьОтчёт отчёт))
     иначе (ПечататьОшибку "некорректные данные"))
 
 (// Определение типа на основе практики)
 (структ АнализДанных
-  показатель ПроцентПлана
-  дата       АбсолютнаяМетка
-  регион     РегионПеречисление
-  док        "Анализ данных по регионам с привязкой по времени")
+  @показатель ПроцентПлана
+  @дата       АбсолютнаяМетка
+  @регион     РегионПеречисление
+  @_док       "Анализ данных по регионам с привязкой по времени")
 ```
 
 От хаоса внешнего мира → к порядку внутренней системы через безопасные однонаправленные шлюзы.

docs/prolet-009.md

@@ -4,20 +4,20 @@
 
 Рассмотрим корень диалектического материализма, его онтологическую основу:
 
-- Сущее vs Несущее,
-- Бытие vs Небытие,
-- Материя vs Пустота,
-- Наличие vs Отсутствие.
+- `Сущее` vs `не сущее`,
+- `Бытие` vs `Небытие`,
+- `Материя` vs `Пустота`,
+- `Наличие` vs `Отсутствие`.
 
 Это не просто «обработка nil» — это фундаментальное противоречие, лежащее в основе всего сущего. И если мы хотим построить язык, который отражает реально существующий мир, а не идеальный мир платоновских форм, то мы обязаны решить это противоречие диалектически, а не технически, или прагматически, или сугубо субъективно.
 
-## Философская основа: "сущее и несущее" в диалектическом материализме
+## Философская основа: "сущее и не сущее" в диалектическом материализме
 
 ### Материя первична — сущее есть
 
 В диалектическом материализме только _объективно существующее_ — _есть_.
 
-Всё остальное — отражение, потенциальность, но не бытие.
+Всё остальное — отражение, потенциальность, но не `бытие`.
 
 `Сущее` — это то, что взаимодействует с миром, что занимает место в пространстве-времени, что оказывает воздействие.
 
@@ -25,11 +25,11 @@
 
 Но! Диалектика учит: ничто не возникает из ничего, и ничто не исчезает в ничто.
 
-Следовательно, `не сущее` — не абстракция, а момент развития материи.
+Следовательно, `не сущее` — не абстракция, а момент развития материи вне установленных философских категорий -- `нечто`.
 
 ### Противоречие в программировании: null, undefined, None, nil
 
-В большинстве языков: `null` — это "значение, которое не есть значение".
+В большинстве языков: `nil` — это "значение, которое не есть значение".
 
 Это — онтологическая ошибка: признание существования небытия как равноправного с бытием.
 
@@ -40,9 +40,9 @@ String name = user.getName(); // может быть null
 int len = name.length();     // NullPointerException — ошибка на миллиард долларов
 ```
 
-Это — не ошибка программиста, это — ошибка _онтологии языка_, который допускает, что "не-сущее" может передаваться как "сущее".
+Это — не ошибка программиста, это — ошибка _онтологии языка_, который допускает, что `не сущее` может передаваться как `сущее`.
 
-## Идеалистические ошибки в типизации "сущее/несущее"
+## Идеалистические ошибки в типизации "сущее/не сущее"
 
 ### C/C++
 
@@ -73,78 +73,78 @@ int len = name.length();     // NullPointerException — ошибка на ми
 - признают небытие как форму бытия,
 - вместо того, чтобы разрешить противоречие через практику.
 
-## Диалектическое решение: "сущее" и "не-сущее" как противоположности в движении
+## Диалектическое решение: "сущее" и "нечто" как реально существующие противоположности в движении
 
 Принципы онтологии языка `prolet`:
 
-- Только сущее может быть значением.
+- Только `сущее` может быть значением.
 - Если чего-то нет — оно не может быть передано, не может быть переменной, не может быть в вычислении.
-- "Не-сущее" — не значение, а состояние процесса.
-- Оно не существует само по себе, а возникает в практике получения сущего.
-- Переход от "несущего" к "сущему" — через труд, проверку, практику.
+- `нечто` — не значение, а реально существующее состояние процесса.
+- Оно не существует само по себе, а возникает в практике получения сущего без формы.
+- Переход от `нечто` к `сущему` — через труд, проверку, практику.
 - Как в жизни: хлеб не берётся из воздуха — он выращивается, обрабатывается, доставляется.
 - Язык не допускает "пустоту" как объект — он требует решения.
 
-Нет `null`. Нет `None`. Есть альтернатива или сущее.
+Нет `null`. Нет `None`. Есть `нечто` как сущее, но неопределённое.
 
-## Механизм: возможно — не тип, а зона поиска сущего
+## Механизм: нечто — тип, как пространство поиска сущего
 
-Вместо `Option<T>` или `null` — вводим оператор возможно, который не является типом, а обозначает зону неопределённости, в которой ещё не решено, есть ли сущее. Но сама содержащая неопределённость сущность -- всегда существует
+Вместо `Option<T>` или `null` — вводим сущность `нечто`, которая является типом, обозначает пространство неопределённости, в котором ещё не решено, есть ли сущее. Но сама содержащая неопределённость сущность `нечто` -- существует всегда.
 
 ```prolet
 (// 1. Внешний источник — может не дать сущего,
 если шлюз принимает данные не от prolet-процесса)
-(прц ЗапросИзАпи @шлюз_вход @возможно () -> данные
+(прц ЗапросИзАпи @шлюз_вход () -> нечто
     ...)
 
-(// Внутри `возможно` — нельзя использовать напрямую,
+(// Внутри `нечто` — нельзя использовать напрямую,
 ОШИБКА КОМПИЛЯЦИИ )
 (ОбработатьДанные)
 
 (// Переход к сущему — только через практику)
-(ЕслиПробаИз данные как Пользователь
-    тогда (Обработать (ПривестиИз данные к Пользователь))    (// данные — теперь сущее)
+(ЕслиНечто нечто как Пользователь
+    тогда (Обработать (Привести нечто к Пользователь))    (// нечто — теперь сущее)
     иначе (ВосстановитьПоУмолчанию)) (// нет сущего — альтернатива)
 ```
 
 Ключевые особенности:
 
-- `@возможно` — не тип, а атрибут для определения пространства возможного.
-- Переменная возможно не имеет значения до проверки.
-- После тэга `ЕслиПробаИз` — в ветке `тогда` переменная становится сущей.
+- `нечто` — тип для определения пространства возможного.
+- Переменная нечто имеет значение до проверки, но не имеет определённого типа
+- После тэга `ЕслиНечто` — в ветке `тогда` переменная становится сущей.
 - В ветке `иначе` — альтернативное действие.
 
-Это — единство бытия и не-бытия в процессе познания:
+Это — единство бытия и небытия в процессе познания:
 
-- пока не проверили — нет сущего,
+- пока не проверили — нечто, а не сущее,
 - после проверки — сущее возникает как результат практики.
 
 ## Онтологическая строгость: никакого "значения-пустоты"
 
 Сравните:
 
+### Небытие-значение (ошибка)
+
 ```Java
 String s = null;
 ```
 
-Пустота — значение
+### Небытие — обёрнуто, но существует (потенциальная ошибка)
 
 ```Rust
 let s: Option<String> = None;
 ```
 
-Пустота — обёрнута, но существует
+### Нечто — не значение, а состояние поиска
 
 ```prolet
-((прц ИзПорта @шлюз_вход @возможно) -> @фикс СбщСырое)
+((прц ИзПорта @шлюз_вход) -> @фикс нечто)
 ```
 
-Пустота — не значение, а состояние поиска
-
 В `prolet` нельзя написать:
 
 ```lisp
-((Уст Пусто) -> @фикс дыра) (// ОШИБКА: "ничего" не есть)
+(уст (Пусто) @фикс дыра) (// ОШИБКА: "ничего" не есть)
 ```
 
 Потому _что ничего не есть_.
@@ -154,10 +154,13 @@ let s: Option<String> = None;
 ### Форма 1: Проверка (познание через практику)
 
 ```prolet
-((НайтиПоНомеру (123 125)) -> данные)
+((НайтиПоНомеру (123 125)) -> нечто)
 
-(ЕслиПробаИз данные как Пользователь
-    тогда (напечатать "Здравствуй, " данные.Имя)
+(ЕслиНечто нечто как Пользователь
+    тогда (
+        (уст (Привести нечто к Пользователь) пользователь)
+        (напечатать "Здравствуй, " пользователь имя)
+    )
     иначе (напечатать "Пользователь не найден"))
 ```
 
@@ -166,11 +169,11 @@ let s: Option<String> = None;
 ## Форма 2: Принудительное извлечение (с ответственностью)
 
 ```lisp
-(фн ПрочитатьФайл @шлюз_вход @возможно () -> @фикс данные)
+(фн ПрочитатьФайл @шлюз_вход() -> @фикс нечто)
 
-(ГарантВозможно данные как Пользователь
+(ГарантНечто нечто как Пользователь
     @_док "данные обязательны, ошибка конфигурации"
-    иначе ((ПользовательИзСтроки данные) -> @фикс пользователь)
+    иначе (уст (ПользовательНовый) @фикс пользователь)
 ```
 
 Гарантировать — не отрицание онтологии, а утверждение сущего на основе практики.
@@ -179,13 +182,13 @@ let s: Option<String> = None;
 
 ## Педагогический и психологический аспект
 
-- Новичок не может использовать `@возможно` без если-возможно.
-- `гарант-возможно` вернёт сущее.
+- Новичок не может использовать `нечто` без `ЕслиНечто`.
+- `ГарантНечто` вернёт сущее.
 
-IDE подсвечивает:
+**IDE** подсвечивает:
 
-- "Переменная 'данные' — возможно, _небытие_. Проверьте перед использованием."
-- При попытке передать `@возможно` в функцию, ожидающую сущее — ошибка компиляции.
+- "Переменная 'нечто' — не содержит конкретной формы. Проверьте перед использованием."
+- При попытке передать `нечто` в функцию, ожидающую сущее — ошибка компиляции.
 
 Это — формирование диалектического сознания: программист учится не признавать пустоту как бытие, а искать сущее в практике.
 
@@ -194,7 +197,7 @@ IDE подсвечивает:
 ### Бытие
 
 - Только то, что существует, имеет форму, действует
-- Переход от "возможно" к "сущему" через проверку
+- Переход от `нечто` к `сущему` через проверку
 
 ### Небытие
 
@@ -203,7 +206,7 @@ IDE подсвечивает:
 
 ### Ошибка онтологии
 
-Использование null, а не признания небытия как нечто сущее
+Не Использование `nil`, а признания небытия как невозможное в реальном мире
 
 Язык не допускает онтологической лжи.
 
@@ -215,11 +218,11 @@ IDE подсвечивает:
 
 ## Заключение: язык как отражение реального мира
 
-Дано решение главное противоречие:
+Дано решение главного противоречия:
 
 `prolet` не допускает ошибки на миллиард долларов, потому что он не допускает лжи онтологии.
 
-- В нём нет места `null`, потому что _ничего не есть_.
+- В нём нет места `nil`, потому что _ничего не есть_.
 - В нём есть место практике, потому что сущее рождается в труде.
 - В нём есть место неопределённости, но не как значению, а как пространству поиска.
 - В нём программист — не маг, а труженик, добывающий сущее из потенциально сущего.

docs/prolet-010.md

@@ -9,7 +9,7 @@
 
 Мы уже отвергли идеалистические перекосы:
 
-- `null` как "сущее небытие",
+- `nil` как "сущее небытие",
 - динамика как хаос,
 - синтаксис как идеалистическая бюрократия.
 
@@ -30,7 +30,7 @@
 
 Противоречие: Простые типы не отражают сложность мира. Возникает потребность в составных. Простые типы поглощаются составными.
 
-`struct` , `class` , `tuple`
+`struct` , `type` , `tuple`, `list`
 
 Кроме того, `Целое` — как простой тип не просто число, а объект с поведением. Поведение объекта, способы взаимодействия с миром определяются свойствами самого объекта. С другой стороны, те же свойства объекта диалектически накладывают ограничения на тот же объект.
 
@@ -103,59 +103,55 @@
 Нет `string` . Есть `Имя` , `Хэш` , `Запрос` , `Ответ` .
 
 ```prolet
-(тип Рубль Рубля Рублей        (// синонимы типа)
-    @_база    Целое            (// Абстракция в основе типа)
+(тип Рубль или Рубля или Рублей (// синонимы типа)
+    @_база    Целое             (// Абстракция в основе типа)
     @_диапазон (0 999_999_999)  (// Допустимый диапазон на базе абстрактного типа)
     @_операции (слож выч))      (// Допустимые операции над конкретным типом)
 ```
 
 Примитив не уничтожен, но воспроизведён на новом уровне — как осмысленная категория.
 
-### Онтологическое уточнение: атрибут `@база Целое`
+### Онтологическое уточнение: свойство `@_база Целое`
 
-Атрибут `@база` опирается на математическую абстракцию `Целое` , но по отношению к материалистичному миру является сущим _только в рамках математического дискурса_.
+Свойство `@_база` опирается на аппаратную абстракцию `Целое`, но по отношению к материалистичному миру является сущим _только в рамках математического дискурса_. Т.е. математические типы не ограничиваются типом `Целое`. Но этим типом ограничивает аппаратура.
 
-Это — _ключевое_ уточнение, которое позволяет не отступать от диалектического материализма, но признать относительную самостоятельность математического мышления как _специфической формы отражения реальности_.
+Это — _ключевое_ уточнение, которое позволяет не отступать от диалектического материализма, но признать относительную самостоятельность аппаратного, равно и математического мышления как _специфической формы отражения реальности_.
 
 ### Интерпретация
 
-```text
-ПОНЯТИЕ         |          СТАТУС В ОНТОЛОГИИ PROLET
-----------------|---------------------------------------------------------------
-Целое           |   Не первичная данность, а результат высшего обобщения практики счёта
-                |  (считали камни, яблоки, дни — и выделили общую форму)
-----------------|---------------------------------------------------------------
-Математический  |  Специфическая социальная практика, в которой абстракция (вроде `Целое`)
-дискурс         |  обращаются как сущее, хотя она и есть специфичная форма материи
-----------------|---------------------------------------------------------------
-@база           |  Указание на форму, заимствованную из математического дискурса, но
-                |  используемую как инструмент для организации сущего
-```
+ПОНЯТИЕ|          СТАТУС В ОНТОЛОГИИ PROLET
+ -------- | -----------------------------------
+`Целое`    | Не первичная данность, а результат высшего обобщения практики счёта (считали камни, яблоки, дни — и выделили общую форму)
+Аппаратный дискурс | Специфическая техническая практика, в которой абстракция (вроде `Целое`) обращаются как сущее, хотя она и есть специфичная форма материи
+@база      | Указание на форму, заимствованную из математического дискурса, но используемую как инструмент для организации сущего
 
 Это — не признание платонизма, а признание автономии отражения.
 
-Как язык отражает мир, так и математика — отражает количественные отношения, но не существует вне практики.
+Как язык отражает мир, так и аппаратура, так и математика — отражает количественные отношения, и эти отношения не существуют вне практики.
 
 📜 Принципы объявления типов `prolet`
 
 - Тип — только материализованная форма сущего
 - `Целое`,  `Строка`,  `Дробное`,  `Логическое` — не типы, а базовые абстракции
-- `база` — не наследование, а заимствование формы из дискурса математики
+- `@база` — не наследование, а заимствование формы из дискурса аппаратного обеспечения
 - Тип всегда имеет социальный, экономический или технический контекст
-- Без атрибутов, отражающих практику — _нет типа_
-- Определение вида `(тип Целое ...)` — ошибка онтологии, запрещено
+- Без свойств, отражающих практику — _нет типа_
+- Определение вида c использованием аппаратного типа `(тип Целое ...)` — ошибка онтологии, запрещено
 
 ## Стадия 2: Сложное — как единство противоположностей
 
-Структура — не просто набор полей, а единство противоречий:
+Структура — не просто набор свойств, а единство противоречий:
 
 ```prolet
-(тип Роль
+
+(// любой тип имеет одно значение,
+не число свойств может быть любым)
+(тип Роль или Права
     @_обязательно
     @_база Перечисление
     @_выбор_ (Админ Пользователь Гость)
     @значение Гость (// По умолчанию, можно менять)
-    @_док "Роль пользователя в системе")
+    @_док "Роль пользователя в системе"
 
 (тип ПользовательНомер
     @_обязательно
@@ -163,10 +159,9 @@
     @_диапазон      (1 999_999_999)
     @_автоИнкремент
     @_уникально
-    @_док      "идентификация пользователя в системе")
+    @_док ( "идентификация пользователя в системе")
 
-(тип Имя
-    @_обязательно
+(тип Имя или Название
     @_база      Строка
     @_умолчание "Иван"
     @_док       "идентификация пользователя в системе")
@@ -180,84 +175,75 @@
 )
 ```
 
-Поле в структуре может ссылаться только на практический тип — то есть на материализованное сущее.
-Прямая ссылка на базовую абстракцию (`Целое`, `Строка` и т.п.) — запрещена.
+Свойство в структуре может ссылаться только на практический тип — то есть на материализованное сущее (тип или структура).
+
+Прямая ссылка на аппаратную абстракцию вне явно обозначенных границ (`Целое`, `Вещ` и т.п.) — запрещена.
 
-Все атрибуты, помечены префиксами:
+Все свойства, помечены префиксами:
 
 - `@_база` -- системный, нельзя изменить
 - `@значение` -- пользовательский, можно изменять.
 
 В приведённом синтаксисе достигается единство формы и содержания:
 
-- Разделение "атрибут vs поле" — идеализм, ведущий к ложному противопоставлению "сущности" и "её свойств".
+- Разделение "атрибут vs поле" — идеализм, ведущий к ложному противопоставлению "сущности" и "её свойств". В предлагаемом подходе всё является свойством.
 - В реальности — есть только объект с характеристиками: у человека — имя, возраст, роль, статус, история.
 - Нет "основных данных" и "метаданных" — есть все данные как единое сущее.
 
 ### Философский и практический смысл
 
-```text
-АСПЕКТ             ОБЪЯСНЕНИЕ
-------             ---------------------------
-Онтология          Тип — не шаблон, а форма сущего в практике. Если в практике номер
-                    всегда уникален и присваивается автоматически, то эти свойства —
-                    часть его бытия, а не внешнее условие.
-
-Единство нормы     Если ПользовательНомер используется в 10 структурах — не нужно 10 раз писать
-                    @уникально. Нарушение — на уровне типа, а не контекста.
-
-Безопасность       Система гарантирует уникальность и обязательность на уровне типа,
-                    а не доверяет структуре "не забыть".
-
-Эволюция практики  Если правило изменится (например, номер перестанет быть авто-инкрементным), —
-                    меняется один
-```
+АСПЕКТ    |   ОБЪЯСНЕНИЕ
+  ------  |      ---------------------------
+Онтология |  Тип — не шаблон, а форма сущего в практике. Если в практике номер всегда уникален и присваивается автоматически, то такие свойства — часть его бытия, а не внешнее условие.
+Единство формы  |   Если ПользовательНомер используется в 10 структурах — не нужно 10 раз писать `@уникально`. Нарушение — на уровне типа, а не контекста.
+Безопасность  |  Система гарантирует уникальность и обязательность на уровне типа,    а не доверяет типу "не забыть".
+Эволюция практики  | Если правило изменится (например, номер перестанет быть авто-инкрементным), —  меняется одно свойство в типе
 
 ### Принципы проектирования в prolet
 
-- Тип несёт свои нормы: @обязательно, @уникально, @авто-инкремент, @умолчание — определяются в (тип ...)
+- Тип несёт свои нормы: `@обязательно`, `@уникально`, `@авто-инкремент`, `@умолчание` — определяются в (тип ...)
 - Структура — композиция, а не конфигурация: она не задаёт правила, а использует уже заданные
-- Атрибуты в структуре — только контекстные: например, @источник, @момент, @ответственный, но не базовые свойства типа
-- Повторное указание атрибутов типа в структуре — избыточно и запрещено, но не запрещены атрибуты самого поля
-- Тип — законченная форма сущего, пригодная к использованию в любой структуре
+- Свойства в структуре — только контекстные: например, `@источник`, `@момент`, `@ответственный`, но не базовые свойства типа
+- Повторное указание свойств типа в структуре — избыточно и запрещено, но не запрещены свойства самого свойства (свойство структуры рассматривается как тип на своём уровне)
+- Тип — со всеми своими свойствами, законченная форма сущего, пригодная к использованию в любой структуре
 
 ## Форма 3: интерфейс — тип как отношение
 
 ```prolet
 (интерфейс ИХранилище
     @_док "Абстракция работы с хранилищем"
-    (ПолучФайл (имя @фикс ИмяФайла) -> @фикс Результат Спис.Байт
+    (ПолучФайл (имя ИмяФайла @фикс) ->Результат Спис.Байт @фикс
         @_док "Читает файл с диска")
     (ЗаписатьФайл (имя @фикс ИмяФайла данные @фикс Спис.Байт) -> @фикс Результат Логическое
         @_док "Записывает файл на диск")
     (ЗакрытьХранилище)
 )
 
-(ПолучИнтерфейс НовХранилище как ИХранилище -> мут хран)
-((ПолучФайл хран получить "test.txt") -> _)
+(уст (НовХранилище) @мут хран)
+(хран ПолучФайл "test.txt")
 ```
 
-Тип определяется не сущностью, а связями — как в диалектике.
+Интерфейс определяется не сущностью, а связями — как в диалектике.
 
 - интерфейс — объявляет форму взаимодействия, а не математическую сигнатуру
-- Каждый метод — глагол, отражающий практику
-- Параметры: `(@имя Тип, @данные Тип)` — именованные, ссылаются на типы
+- Каждое действие — глагол, отражающий практику
+- Параметры: `(имя Тип, данные Тип)` — именованные, ссылаются на типы
 - Возврат: (Результат Тип) — структура, отражающая результат практики
 - Возвращаемый результат может отсутствовать
-- Все типы в интерфейсе — практические, определённые через (тип ...)
-- @_док — не обязателен для каждого метода и интерфейса, но можно потребовать обязательность на уровне проекта
-- Интерфейс не содержит реализации — только методы с параметрами и возвращаемые значения
+- Все типы в интерфейсе — практические, определённые через (тип, структ, ...)
+- @_док — не обязателен для каждого метода и интерфейса, но можно потребовать обязательность на уровне проекта или конкретного действия
+- Интерфейс не содержит реализации — только действия с параметрами и возвращаемые значения
 
 ## Онтологическая иерархия типов
 
 ```text
-    Обобщённые абстракции (отрицание)
+    Математические типы (отрицание)
       ↓
     Конкретные типы (противоположность)
       ↓
     Структуры (синтез)
       ↓           ↘
-    атрибуты     методы
+    свойства    действия
                     ^
                 Интерфейсы
 ```