Hacker News Digest

Автор делится своим опытом работы с различными языками программирования, объясняя, почему OCaml стал его любимым языком. Он начал с Haskell, который оценил за функциональное программирование и статическую типизацию, но столкнулся с его сложностью и медленной компиляцией. Позже он попробовал Go, который понравился своей простотой, скоростью компиляции и хорошими инструментами, но разочаровал многословностью обработки ошибок и отсутствием функциональных возможностей. OCaml, по мнению автора, сочетает в себе лучшее из обоих миров: функциональные конструкции, статические гарантии, быструю компиляцию, простую семантику выполнения и отличную документацию. Особо отмечается, что OCaml компилируется в один статический бинарный файл, как Go, но при этом имеет более мощную систему типов и REPL. Автор считает, что создатели OCaml обладают хорошим вкусом, а язык представляет собой идеальный баланс между простотой и выразительностью.

• OCaml не стал мейнстримом из-за синтаксиса, отсутствия нативных библиотек и слабой экосистемы, но его идеи (pattern-matching, type inference, algebraic data types) уже давно живут в Rust, Swift, TypeScript и даже Go.
• Фактически OCaml — это «нативный» вариант F#, но без .NET-экосистемы, а F# — это OCaml без его синтаксиса и с .NET вместо OCaml-стандартной библиотеки.
• Попытка ReasonML привнести более C-подобный синтаксис вместо ужасающего синтаксиса OCaml закончилась тем, что Facebook забросил проект, а вся индустрия JS-инструментов осталась без единого стандарта.
• Попытка Facebook-а внедрить Reason вместо TypeScript внутри Facebook показала, что даже если синтаксис и не является проблемой, то отсутствие единого стандарта для сборки и пакетов в JS-мире оставляет язык без шанса.
• Несмотря на то, что OCaml — это язык с 25-летней историей, он не имеет ни мультиплатформенной сборки, ни нормального менеджера пакетов, ни нормального REPL, что делает его неподготовленным к работе вне Unix-подобных систем.

Разработчики Stategraph выбрали OCaml для управления состоянием Terraform, поскольку корректность здесь критически важна. Система хранит состояние как граф зависимостей в PostgreSQL с блокировкой на уровне ресурсов. OCaml позволяет улавливать целые категории ошибок на этапе компиляции, что невозможно в других языках. Сильная типизация данных предотвращает доступ к несуществующим полям, а неизменяемые структуры по умолчанию исключают условия гонки.

Типобезопасные SQL-записи предотвращают дрейф схемы до развертывания, а PPX автоматически генерирует корректную сериализацию JSON. Как отмечают разработчики: "Мы строим инфраструктуру, которая управляет инфраструктурой других людей. Повреждение состояния не может быть 'редким'. Оно должно быть невозможным". Компилятор OCaml обеспечивает безопасность на уровне типов, проверяя все переходы состояний и записи в базе данных, что значительно снижает количество ошибок по сравнению с традиционным подходом, основанным на тестировании.

• Обсуждение показало, что выбор языка часто опирается на субъективные предпочтения и эстетику, а не только на технические аргументы.
• Участники подчеркнули, что такие факторы, как удобство найма разработчиков и удержание их мотивации, могут быть более важными, чем технические характеристики.
• Была поднята тема лицензий и открытого кода как факторов, которые могут влиять на выбор инструментов.
• Обсуждение также затронуло вопросы стоимости владения инструментом и его экосистемой, включая стоимость обучения и доступность кадров.
• Участники отметили, что хотя технические детали важны, они не всегда являются решающими при выборе стека, особенно если учитывать, что большинство современных языков предлагают сравнимые возможности.

Книга Ксавье Леруа исследует эволюцию управляющих конструкций в языках программирования, от ранних операторов goto до современных алгебраических эффектов. Работа представляет собой историческое путешествие по дизайну языков, уделяя особое внимание механизмам контроля выполнения программ. Книга охватывает структурированное программирование 1960-х, генераторы и корутины в императивных языках, а также продолжения и операторы контроля в функциональных языках.

Книга разделена на четыре части: управляющие конструкции для императивных языков, операторы контроля для функциональных языков, от исключений к алгебраическим эффектам и обработчикам, а также рассуждения о контроле и эффектах. Особую ценность представляют многочисленные примеры кода на разных языках — от Fortran и Algol 60 до OCaml и Haskell. Работа сочетает историю, практические примеры и теорию, предлагая оригинальный сравнительный взгляд на языки программирования и обширное введение в алгебраические эффекты — современную область исследований в PL.

• Критика исключений как "glorified come from", сравнение с POSIX сигналами и setjmp/longjmp.
• Дискуссия о checked исключениях в Java vs подход "ошибки как данные" для ожидаемых сбоев.
• Вопрос производительности алгебраических эффектов и ответ: реализация возможна через монады, оптимизирована в OCaml 5.
• Упоминание Xavier Leroy как автора CompCert, LinuxThreads и ключевой фигуры OCaml/Rocq.
• Шутка про INTERCAL и "come from" как пример необычного синтаксиса.

Lone Lisp теперь поддерживает ограниченные продолжения — мощный механизм управления потоком выполнения. Это позволяет сохранять и восстанавливать состояние вычислений в определённых точках, что открывает путь к реализации генераторов, обработки исключений и других сложных конструкций. Пример кода демонстрирует, как control и transfer работают вместе: (control ...) захватывает контекст, а (transfer ...) передаёт управление, позволяя гибко манипулировать выполнением.

Изначально проблема возникла при реализации итераций: из-за рекурсивной природы интерпретатора и управления стеком на уровне C было невозможно контролировать поток. Решение потребовало переосмысления архитектуры — вместо байткода или трансформаций в стиле продолжений автор выбрал подход, сохраняющий списковую структуру Lisp. Это сложный, но фундаментальный шаг, вдохновлённый классическими работами вроде SICP.

• Wat реализует стек вызовов в пользовательском пространстве для поддержки ограниченных продолжений, что позволяет создавать исключения, ветвление и файберы.
• Вопрос о практическом применении ограниченных продолжений за пределами хобби-проектов и их реальном использовании в промышленности.
• Примеры использования в Ocaml 5 (библиотека Eio), Haskell (GHC, работа приостановлена) и Racket (стандартная модель для обработки ошибок и прерываний).
• Java использует ограниченные продолжения как основу для своих новых "зеленых" потоков (виртуальных потоков).
• Обсуждение потенциальных сфер применения, таких как встраиваемые системы.

std::flip — это малоизвестная утилита из стандартной библиотеки C++ в заголовке <functional>, которая принимает вызываемый объект и возвращает его аналог с обратным порядком параметров. Она особенно полезна для переворачивания предикатов, например, чтобы проверить, является ли один узел дерева потомком другого, создав функцию is_descendant_of через std::flip(is_ancestor_of), что зеркально отражает логику предка.

Идея пришла из функционального программирования: аналоги есть в Haskell, PureScript, OCaml и других языках, а также в библиотеках вроде Boost.Hana и Ramda. В сочетании с std::not_fn она позволяет выражать все операторы сравнения через один базовый предикат, упрощая generic-алгоритмы — например, проверку обратной сортировки или реализацию upper_bound через lower_bound. Это элегантный инструмент для сокращения кода и повышения его переиспользуемости.

• Сомнения в существовании std::flip в C++ и критика его потенциального имени и нишевости.
• Обсуждение недостающих для функционального стиля элементов C++: сопоставление с образцом и унифицированный синтаксис вызова.
• Критика сложности предложенной реализации flip и её потенциальной бесполезности или опасности.
• Дебаты о практической полезности функции flip и её аналогов в других языках.
• Обсуждение проблем представления геоданных и применимости flip как потенциального источника ошибок.

В программировании «алгебра» — это не школьные уравнения, а способ давать коду строгую структуру через свойства операций. Если обычная композиция объектов ограничивается «они реализуют один интерфейс», то алгебраическая композиция требует, чтобы набор данных и операций удовлетворял фиксированным законам: замкнутость, ассоциативность, единица, обратные элементы и т.д. Набор «целые числа + сложение» образует группу, потому что все четыре закона выполняются; код, в котором сложение строк вдруг выдаёт число, группой не является.

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

• Обсуждается различие между "алгебраическими" в контексте типов данных и эффектов, подчеркивая, что последние связаны с алгеброй монад, а не просто наличием уравнений.
• Участники предлагают ресурсы для изучения темы (статья "What is algebraic about algebraic effects and handlers?") и проводят аналогии с булевой алгеброй для лучшего понимания.
• Отмечается сложность терминологии и необходимость перевода абстрактных математических концепций (операции над типами/эффектами) в более доступные для программистов термины.
• Поднимается вопрос о синтаксическом представлении алгебраических типов (сумм и произведений) в разных языках программирования (OCaml, Lean).
• Обсуждается практическое применение алгебраических операторов на примере пакета Algebra of Graphics для Julia.

Алгебраические эффекты на практике в Flix

Алгебраические эффекты — уже не академия. Это рабочий инструмент, который сегодня делает код:

1. Тестируемым — «что» отделено от «как»; mock-и и DI не нужны.
2. Прозрачным — сигнатура функции сразу показывает все побочные действия (IO, сеть, исключения).
3. Гибким — async/await, корутины, backtracking реализуются обычными библиотеками, без изменения языка.

В отличие от монад, эффекты понятны без теории категорий и работают «из коробки» в языке Flix.

---

Мотивирующий пример

Без эффектов:

def calculateSalary(base, percent) -> float:
    # может отправить письмо бабушке

С эффектами (Flix):

def calculateSalary(base: Float64, percent: Float64): Float64 \ {Email} =
    ...

Сигнатура не лжёт: любой вызов Email будет отслежен компилятором.

---

Обработчики эффектов (интуиция)

Эффект = операция + обработчик.
Код бросает операцию, обработчик решает, что с ней делать.

eff Ask {                     // объявляем эффект
    pub def ask(): String
}

def greet(): String \ Ask =   // используем
    "Hello " + Ask.ask()

def main(): Unit =            // обрабатываем
    println(greet() with Ask {
        def ask() = "World"
    })

---

Реальный проект: рекомендательная система фильмов

Задача: достать данные из SQLite, вызвать внешний AI-сервис, кешировать результат, логировать.

Эффекты: Db, Http, Log, Cache.

def recommend(user: String): List[Movie] \ {Db, Http, Log, Cache} = 
    Cache.getOrElse(user, 
        for {
            prefs <- Db.query(user)
            _     <- Log.info("Prefs loaded")
            recs  <- Http.post("ai.example.com", prefs)
            _     <- Log.info("AI answered")
            _     <- Cache.put(user, recs)
        } yield recs)

Тест: подменяем обработчики на in-memory реализации — никаких реальных запросов.

---

Куда дальше

• Попробовать онлайн: https://play.flix.dev
• Документация: https://doc.flix.dev
• Репозиторий: https://github.com/flix/flix

Flix ещё молод, но уже поддерживает эффекты, регионы, структурную конкурентность и Datalog.

• Участники восторгаются идеей алгебраических эффектов: они проще монад, решают «цветную» проблему функций и позволяют гибко компоновать побочные эффекты.
• Примеры уже есть: экспериментальная реализация в OCaml 5, библиотеки Effect и Effectively для TypeScript, языки Koka, Effekt, Unison.
• Отличие от ОО-интерфейсов: эффекты явно указывают контекстные требования (Net, IO) и позволяют подменять реализацию динамически, а не статически.
• Критика: система всё равно «окрашивает» код, требует прокидывать эффекты через весь стек вызовов и пока выглядит академично/громоздко.
• Практические вопросы: как скрыть «дебажный» вывод, не нарушая типов, и можно ли обойтись без переписывания сигнатур каждой промежуточной функции.

• Эволюция OCaml – Ashoka Univ, сент 2025 [pdf][key]
• Авто-проверка реплиц. типов – NUS, авг 2025 [pdf][key]
• AI-инструменты для исследований – IIT Madras, июль 2025 [pdf][key]
• Параллельный рантайм OCaml – Chalmers, май 2025 [pdf][key]
• Авто-проверка реплиц. типов – WG 2.8, май 2025 [pdf][key]
• Параллельный OCaml 5 – Bloomberg, мар 2025 [pdf][key]
• Параллельный OCaml 5 – IIT Gandhinagar, мар 2025 [pdf][key]
• Параллельный OCaml 5 (ч.1) – PACE Lab, фев 2025 [pdf][key]
• Безопасность памяти и ЯП – Schaeffler @ IITM, фев 2025 [pdf][key]
• Мини-ОС через Unikernels – Daekin–IITM, янв 2025 [pdf][key]
• Безопасные Unikernels с аппаратной поддержкой – CAIR DRDO, ноя 2024 [pdf][key]
• Параллельный OCaml 5 – Meta London, сен 2024 [pdf][key]
• Зачем OCaml? – Rezilyens, авг 2024 [pdf][key]
• Эффекты и конкурентность – Chalmers, май 2024 [pdf][key]
• Безопасность функциональных программ – WG 2.8, апр 2024 [pdf][key]
• Композиция библиотек конкурентности – EHOP, июл 2023 [pdf][key]
• Сливаемые реплиц. типы – Collège de France, апр 2023 [pdf][key][видео]
• OCaml 5.0 – OCaml Workshop, сен 2022 [pdf][key]
• Ретрофит конкурентности – ICFP keynote, сен 2022 [pdf][key][видео]
• Сертифицированные сливаемые типы – PLDI, июн 2022 [pdf][key][видео]
• Сертифицированные сливаемые типы – Nomadic Labs, апр 2022 [pdf][key][видео]
• Параллелизм в OCaml – Marigold, дек 2021
• Эффекты в OCaml 5 – Huawei STW, окт 2021 [pdf][key]
• Эффекты в OCaml – SimCorp, сен 2021 [pdf][key]
• Параллелизм в OCaml – SimCorp, сен 2021 [pdf][key]
• ParaFuzz: фаззинг многопоточных программ – Dagstuhl, 2021

• Доклад — субъективный взгляд на 10-летнюю эволюцию OCaml; цель — убрать мистику вокруг разработки компилятора и заманить новых контрибьюторов.
• Главный бытовой pain-point: в стандартной библиотеке исключения — часть API, и они не типизированы, что подрывает «безопасность» языка.
• Выход — использовать Jane Street Core/Base (функции либо возвращают Result, либо помечены _exn), но большинство проектов всё ещё живёт на обычной Stdlib.
• «Большие» альтернативы Stdlib (Core, Base) существуют, но их значение часто преувеличено; официальная библиотека за последние годы всё-таки подросла полезными функциями.
• Новичкам в компиляторщине советуют начинать с мелких багов и мини-Pull Request’ов, а не пытаться сразу «съесть слона».

Rust повышает производительность разработки, несмотря на сложность.
Ключевые факторы:

• Жёсткий компилятор ловит ошибки до запуска, уменьшая время отладки.
• Модель владения устраняет гонки и утечки памяти, снижая количество багов.
• Инструменты: Cargo, Clippy, rustfmt и rust-analyzer ускоряют цикл «написание → проверка → запуск».
• Сообщество предлагает качественные крейты и быструю помощь.
• Производительность кода сравнима с C/C++, но без segfault и UB.

В итоге меньше времени тратится на отладку, больше — на новые функции.

• Автор статьи рассказал, как Rust позволяет безболезненно рефакторить большие кодовые базы благодаря строгой типизации и проверкам компилятора.
• Многие участники согласились, что статическая типизация (Rust, Haskell, OCaml-подобные языки) повышает уверенность при изменениях, особенно в многолюдных проектах.
• Часть комментаторов считает сравнение с TypeScript «нечестным»: TS компилируется в JS и наследует его недостатки, а приведённый баг с window.location.href — это особенность DOM, а не языка.
• Некоторые отметили, что Rust тоже не идеален: async/синхронные блокировки, медленная компиляция и «множество способов сделать одно и то же» могут снижать удобство.
• Общий вывод: преимущество Rust в безопасности и рефакторинге особенно заметно на больших проектах, но язык требует времени на изучение и не всегда лучше «классических» статически типизированных альтернатив.

• Цель стажировки – заложить основу для системы рефакторинга в Merlin, вдохновлённой IntelliJ и Gleam.

• Первый эксперимент – команда «вынести выражение на верхний уровень» (extract to toplevel).

• Как работает

  1. Выделяется наибольшее выражение внутри выбранного фрагмента.
  2. Оно переносится в новое let-связывание на уровень выше.
  3. Если выражение не чистое, создаётся thunk unit -> …, чтобы сохранить семантику.
  4. Свободные переменные превращаются в параметры новой функции.

• Примеры

  • Константа 3.14159 → let const_name1 = 3.14159.
  • print_endline внутри блока → оборачивается в fun () -> ….
  • a + b + c + (c * x * y) + z → функция, принимающая x, y, a, b, c.

• Результат – работающий прототип, готовый к расширению другими командами.

• Участники рады появлению базового рефакторинга «extract expression» и обсуждают, какие более продвинутые преобразования (например, map ↔ for) хотели бы видеть.
• Уточняли, будет ли автоматически заменяться одинаковый код в той же области видимости: пока нет, чтобы не «угадать» намерения пользователя.
• Кто-то делится самописными vim-скриптами для поиска и рефакторинга, работающими на любом языке.
• Поднимался вопрос о поддержке VS Code: разработчики утверждают, что вкладывают время и в VS Code, и в Emacs, но Emacs проще расширять.
• Обсуждали родство OCaml и F#, а также возможность использования ИИ для крупных рефакторингов.

Проект «Zoo» — мини-реализации самых влиятельных статических систем типов последних 50 лет. Начнём с простых и дойдём до зависимых типов. Всё пишем на Rust — просто потому что удобно и забавно строить чисто функциональные языки на не-функциональном.

Это не учебник, а выходные развлечение. За теорией и доказательствами смотрите TAPL, ATTAPL, PFPL и оригинальные статьи (ссылки в приложении). Здесь же — грязные детали реализации: структуры данных, AST, логика, всё, что можно осилить за уик-энд.

Код — идиоматичный Rust с полноценным парсером и тестами (lalrpop, logos, ariadne). Примеры урезаны, но понятнее продакшен-реализаций. Парсинг и MLIR считаем решёнными задачами, поэтому не фокусируемся на них.

Четыре «зверька»:

• Algorithm W (775 строк) — классический Hindley–Milner, полиморфный λ-исчисление.
• System F (1090 строк) — второе λ-исчисление, параметрический полиморфизм, Mini-OCaml.
• System F-ω (3196 строк) — высшие рода, паттерн-матчинг, дататипы, Haskell-lite.
• Calculus of Constructions (6000 строк) — иерархия универсумов, индуктивные типы, крошечный Lean.

MIT-лицензия, хобби-проект. Нашли опечатку — присылайте pull-request.

• Пользователи хвалят Elaboration Zoo как полезный ресурс для изучения нормализации по вычислению и вывода неявных переменных.
• Просят аналогичный «зоопарк» для линейных типов и предлагают добавить быстрый вариант Hindley–Milner из OCaml.
• Автору советуют включить тёмную тему для блоков кода и рассмотреть простой однонаправленный type-checker в духе Featherweight Java.
• Уточняют, что присутствие индуктивных типов делает реализацию ближе к CIC, но Lean всё же сильнее за счёт аксиомы выбора.
• Картинки с животными вызывают путаницу; большинство считают их просто AI-орнаментом без смысловой нагрузки.