Hacker News Digest

Книга Ксавье Леруа исследует эволюцию управляющих конструкций в языках программирования, от ранних операторов 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" как пример необычного синтаксиса.

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

Именно этим объясняется «алгебраичность» 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) и позволяют подменять реализацию динамически, а не статически.
• Критика: система всё равно «окрашивает» код, требует прокидывать эффекты через весь стек вызовов и пока выглядит академично/громоздко.
• Практические вопросы: как скрыть «дебажный» вывод, не нарушая типов, и можно ли обойтись без переписывания сигнатур каждой промежуточной функции.