prolet/docs/prolet-unstate-nil.md

Диалектическая несостоятельность nil

Очередное диалектическое противоречие для рассмотрения сущее - не сущее. Ошибка на миллиард долларов в нашем новом, диалектическо-материалистическом языке недопустима. Наша модель языка должна отражать реально существующий мир.

Рассмотрим корень диалектического материализма, его онтологическую основу:

• Сущее vs Несущее,
• Бытие vs Небытие,
• Материя vs Пустота,
• Наличие vs Отсутствие.

Это не просто «обработка nil» — это фундаментальное противоречие, лежащее в основе всего сущего. И если мы хотим построить язык, который отражает реально существующий мир, а не идеальный мир платоновских форм, то мы обязаны решить это противоречие диалектически, а не технически, или прагматически, или сугубо субъективно.

Философская основа: "сущее и несущее" в диалектическом материализме

Материя первична — сущее есть

В диалектическом материализме только объективно существующее — есть.

Всё остальное — отражение, потенциальность, но не бытие.

Сущее — это то, что взаимодействует с миром, что занимает место в пространстве-времени, что оказывает воздействие.

Не сущее — это отсутствие материи, небытие, ничто.

Но! Диалектика учит: ничто не возникает из ничего, и ничто не исчезает в ничто.

Следовательно, не сущее — не абстракция, а момент развития материи.

Противоречие в программировании: null, undefined, None, nil

В большинстве языков: null — это "значение, которое не есть значение".

Это — онтологическая ошибка: признание существования небытия как равноправного с бытием.

Пример катастрофы:

String name = user.getName(); // может быть null
int len = name.length();     // NullPointerException — ошибка на миллиард долларов

Это — не ошибка программиста, это — ошибка онтологии языка, который допускает, что "не-сущее" может передаваться как "сущее".

Идеалистические ошибки в типизации "сущее/несущее"

C/C++

NULL — указатель в никуда

Допускает использование "ничего" как "чего-то"

Java/Python

null/None — объект-пустота

Придаёт небытию форму бытия

Haskell

Maybe a — чисто, но абстрактно

Отделяет форму от материи

Rust

Option<T> — шаг вперёд, но не до конца

None — всё ещё "значение", хотя и обёрнуто

Все они — идеалистические компромиссы:

• признают небытие как форму бытия,
• вместо того, чтобы разрешить противоречие через практику.

Диалектическое решение: "сущее" и "не-сущее" как противоположности в движении

Принципы онтологии языка prolet:

• Только сущее может быть значением.
• Если чего-то нет — оно не может быть передано, не может быть переменной, не может быть в вычислении.
• "Не-сущее" — не значение, а состояние процесса.
• Оно не существует само по себе, а возникает в практике получения сущего.
• Переход от "несущего" к "сущему" — через труд, проверку, практику.
• Как в жизни: хлеб не берётся из воздуха — он выращивается, обрабатывается, доставляется.
• Язык не допускает "пустоту" как объект — он требует решения.

Нет null. Нет None. Есть альтернатива или сущее.

Механизм: возможно — не тип, а зона поиска сущего

Вместо Option<T> или null — вводим оператор возможно, который не является типом, а обозначает зону неопределённости, в которой ещё не решено, есть ли сущее. Но сама содержащая неопределённость сущность -- всегда существует

(// 1. Внешний источник — может не дать сущего)
(фикс данные (= запрос-из-API)
    @шлюз-вход
    @возможно (// если шлюз принимает данные не от prolet-процесса))

(// Внутри `возможно` — нельзя использовать напрямую)
    (обработать данные) — ОШИБКА КОМПИЛЯЦИИ

(// Переход к сущему — только через практику)
(если-возможно данные для пользователь
    тогда (обработать пользователь)    (// данные — теперь сущее)
    иначе (восстановить-по-умолчанию)) (// нет сущего — альтернатива)

Ключевые особенности:

• @возможно — не тип, а атрибут для определения пространства возможного.
• Переменная возможно не имеет значения до проверки.
• После тэга если-возможно — в ветке тогда переменная становится сущей.
• В ветке иначе — альтернативное действие.

Это — единство бытия и не-бытия в процессе познания:

• пока не проверили — нет сущего,
• после проверки — сущее возникает как результат практики.

Онтологическая строгость: никакого "значения-пустоты"

Сравните:

String s = null;

Пустота — значение

let s: Option<String> = None;

Пустота — обёрнута, но существует

(фикс s (= из-источника
        @шлюз-вход
        @возможно)

Пустота — не значение, а состояние поиска

В "Пролетарии-1" нельзя написать:

(фикс x (= Пусто) (// ОШИБКА: "ничего" не есть))

Потому что ничего не есть.

Практическая реализация: три формы работы с не-сущим

Форма 1: Проверка (познание через практику)

(фикс данные (= найти-по-ID (123 125)
                    @шлюз-вход
                    @возможно))

(если-возможно данные как пользователь
    тогда (напечатать "Здравствуй, " пользователь.имя)
    иначе (напечатать "Пользователь не найден"))

Только после проверки — пользователь становится сущим.

Форма 2: Принудительное извлечение (с ответственностью)

(фикс данные (= загрузить
                @шлюз-вход
                @возможно))

(гарант-возможно данные как пользователь
    @док "данные обязательны, ошибка конфигурации"
    иначе (фикс пользователь (= Пользователь.Нов))

Гарантировать — не отрицание онтологии, а утверждение сущего на основе практики.

Но требует введения небытия и работает только в контролируемых условиях.

Педагогический и психологический аспект

• Новичок не может использовать @возможно без если-возможно.
• гарант-возможно вернёт сущее.

IDE подсвечивает:

• "Переменная 'данные' — возможно, небытие. Проверьте перед использованием."
• При попытке передать @возможно в функцию, ожидающую сущее — ошибка компиляции.

Это — формирование диалектического сознания: программист учится не признавать пустоту как бытие, а искать сущее в практике.

Философское обобщение: онтология языка

Бытие

• Только то, что существует, имеет форму, действует
• Переход от "возможно" к "сущему" через проверку

Небытие

• Не может иметь форму
• Нет возможности перехода к сущему

Ошибка онтологии

Использование null, а не признания небытия как нечто сущее

Язык не допускает онтологической лжи.

Он требует:

• Либо — сущее,
• Либо — честное признание, что его ещё нет,
• Либо — создание альтернативного сущего.

Заключение: язык как отражение реального мира

Дано решение главное противоречие:

prolet не допускает ошибки на миллиард долларов, потому что он не допускает лжи онтологии.

• В нём нет места null, потому что ничего не есть.
• В нём есть место практике, потому что сущее рождается в труде.
• В нём есть место неопределённости, но не как значению, а как пространству поиска.
• В нём программист — не маг, а труженик, добывающий сущее из потенциально сущего.

Это — не просто безопасность, это — материалистическая честность, это — диалектика бытия, воплощённая в синтаксисе.