Zero World capability: явный I/O без глобалов

Идея в одно предложение

Программы Zero делают I/O, потому что им дают на это разрешение, а не потому что они тянутся к ambient-глобалу.

Это разрешение — значение типа World. Рантайм конструирует его перед вызовом main, а ваша программа протаскивает его (или его части) везде, где нужно взаимодействовать с внешним миром.

Почему без глобалов?

Большинство языков позволяет любой функции, где угодно, писать в stdout или открывать файл. У JavaScript есть console.log. У Python — print. У C — printf. Удобство реальное, но и цена тоже: по сигнатуре функции нельзя сказать, может ли она делать I/O. Чтобы узнать, надо читать тело — рекурсивно.

Zero занимает другую позицию. Глобального print нет. Никакого ambient os.Stdout. Если функция делает I/O, этот факт обязан появиться в её сигнатуре, потому что единственный способ делать I/O — это иметь полученный capability.

Выгоды проявляются в трёх местах:

1. Чтение сигнатуры говорит, что функция может делать. Функция, у которой нет World, не может писать в stdout, не может открыть сокет, не может прочитать файл. Система типов делает это твёрдой гарантией.
2. Тестировать чистый код тривиально. Чистым функциям не нужны заглушки для print или моки файловой системы — у них доступа к этому в принципе нет.
3. Агенты могут рассуждать локально. ИИ-агент, генерирующий или чинящий код Zero, может — не читая всю кодовую базу — знать, есть ли у функции, на которую он смотрит, эффекты.

Каноничное использование

Базовая форма из hello-world вам уже знакома:

pub fun main(world: World) -> Void raises {
    check world.out.write("hello from zero\n")
}

Три происходящих штуки:

• main объявляет параметр как world: World. Рантайм отдаёт программе значение World и привязывает его здесь.
• world.out — это стандартный поток вывода, выставленный полем capability World.
• world.out.write(...) пишет строку. Возвращает fallible-значение (запись может упасть), которое check пробрасывает.

Параметр можно переименовать — w: World или io: World, — но world это соглашение, и его стоит держать ради согласованности с более широкой экосистемой Zero.

Что живёт на World

Capability World выставляет поверхности, которые могут понадобиться программе. Точная форма зависит от того, что поддерживает рантайм, но можно ожидать записи для:

• world.out — стандартный вывод.
• world.err — стандартный поток ошибок.
• world.in — стандартный ввод.
• Способ открыть файл, прочитать переменные окружения и подключиться по сети.

Сверьтесь с актуальной документацией стандартной библиотеки Zero на счёт авторитетного списка полей. Некоторые поверхности (сеть, файловая система) могут жить за более узкими capability-типами, доступными через World, а не на верхнем уровне.

Протаскивание capability через код

Цена явных эффектов — любая функция, которой нужен I/O, обязана получить capability. Тянуться к нему неявно нельзя.

fun log(world: World, message: String) -> Void raises {
    check world.out.write(message)
}

pub fun main(world: World) -> Void raises {
    log(world, "starting\n")
    log(world, "done\n")
}

log принимает world, чтобы через него писать. Если бы log не принимала world, тело не смогло бы вызвать world.out.write — привязки просто не существовало бы.

Это больше проброса параметров, чем в языке с ambient-I/O. Взамен весь граф вызовов из main теперь виден по одним только сигнатурам:

• main принимает world, поэтому может делать I/O.
• log принимает world, поэтому может делать I/O.
• Любая функция без world в сигнатуре — не может.

Более узкие capability

Передавать весь World каждой функции — топорный подход; это как раздавать root-привилегии. Паттерн, который Zero поощряет, — принимать только тот кусочек World, который реально нужен:

fun log(out: Stream, message: String) -> Void raises {
    check out.write(message)
}

pub fun main(world: World) -> Void raises {
    log(world.out, "starting\n")
    log(world.out, "done\n")
}

Теперь log получает доступ только к Stream (тот же тип, который выставляет world.out). Он может через него писать, но не может открыть файл или читать из сети. Вызывающий выбрал, что разрешено делать log.

Точные имена типов в реальном коде Zero (Stream, Writer, capability-срезы) будут следовать словарю стандартной библиотеки в вашей версии тулчейна. Паттерн — передавать минимум, не максимум — универсален.

Чистые функции

Функции, которым не нужен World, не должны принимать World. Это отчасти стилевое предпочтение, отчасти обеспечивается системой типов: без capability нельзя сделать I/O.

fun sum(point: Point) -> i32 {
    return point.x + point.y
}

sum чиста по отношению к внешнему миру. Вызывающий, смотрящий на сигнатуру, точно знает, что эта функция ничего не напечатает, ничего не откроет и никуда не сходит. На это свойство может полагаться статический анализатор (или агент), не читая тело.

Capability и raises

Почти каждая операция над capability fallible. world.out.write может упасть, потому что поток закрыт. Открытие файла может упасть, потому что файла нет. Поверхность capability API спарена с raises и check — fallible-операции объявляют режимы отказа в сигнатурах, и вызывающие признают их через check.

Эта комбинация — сердце истории эффектов в Zero:

• Что может произойти → raises { ... }.
• Через что → World (или его кусочек).
• Где → везде, где видны capability и raises.

Этой информации достаточно, чтобы рассуждать об эффектах функции точно, по одной только сигнатуре.

Заметка о тестировании

Capability-based I/O делает тестирование простым по построению. Хотите захватить вывод тестируемой функции? Передайте ей фейковый out capability, который записывает то, что её просили писать. Хотите протестировать функцию, которая должна быть чистой? Не передавайте ей никакого capability — её сигнатура не позволит ей трогать внешний мир.

Стандартная библиотека может предоставлять тестовые харнессы, которые строят фейковые или in-memory capability ровно для этого. Точный API будет эволюционировать с языком; принцип (capability — это значения, которые можно подменить) — это рычаг.

Дальше: Raises и Check

World — половина истории эффектов: поверхности, которые функция может трогать. Вторая половина — отказы: когда что-то идёт не так, как это распространяется? Это разбирается дальше — в Raises и Check.