prolet/docs/prolet-009.md

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

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

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

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

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

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

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

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

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

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

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

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

Следовательно, не сущее — не абстракция, а момент развития материи вне установленных философских категорий -- нечто.

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

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

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

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

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. Внешний источник — может не дать сущего,
если шлюз принимает данные не от prolet-процесса)
(прц ЗапросИзАпи @шлюз_вход () -> нечто
    ...)

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

(// Переход к сущему — только через практику)
(ЕслиНечто нечто как Пользователь
    тогда (Обработать (Привести нечто к Пользователь))    (// нечто — теперь сущее)
    иначе (ВосстановитьПоУмолчанию)) (// нет сущего — альтернатива)

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

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

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

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

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

Сравните:

Небытие-значение (ошибка)

String s = null;

Небытие — обёрнуто, но существует (потенциальная ошибка)

let s: Option<String> = None;

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

((прц ИзПорта @шлюз_вход) -> @фикс нечто)

В prolet нельзя написать:

(уст (Пусто) @фикс дыра) (// ОШИБКА: "ничего" не есть)

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

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

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

((НайтиПоНомеру (123 125)) -> нечто)

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

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

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

(фн ПрочитатьФайл @шлюз_вход() -> @фикс нечто)

(ГарантНечто нечто как Пользователь
    @_док "данные обязательны, ошибка конфигурации"
    иначе (уст (ПользовательНовый) @фикс пользователь)

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

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

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

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

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

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

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

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

Бытие

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

Небытие

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

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

Не Использование nil, а признания небытия как невозможное в реальном мире

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

Он требует:

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

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

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

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

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

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