Rust 1.100: тип never после десяти лет ожидания
Rust 1.100 стабилизирует тип never, кастомные аллокаторы и cooldown зависимостей в Cargo. Что сотня релизов говорит о дизайне языка.

Вот сценарий, который должен быть удивительным, но им не является: в четверг утром вы запускаете rustup update stable, пересобираете workspace из нескольких сотен крейтов и полумиллиона строк кода, и всё компилируется. Никаких предупреждений об устаревании, которые вы не заслужили, никаких внезапных поломок в транзитивной зависимости, никакой лихорадочной фиксации версий. С Rust 1.100, действительно огромным релизом, который наконец стабилизирует never-тип после десятилетия попыток, самое интересное то, насколько незаметным будет обновление почти для всех. Это не случайность. Это результат сотни релизов институциональной дисциплины, и читать этот релиз стоит так, как читают дизайн-документ.
Тип never, или десять лет в работе
Главная фишка 1.100 — тип, у которого по определению нет значений. Тип never, записываемый как !, — это канонический необитаемый тип: он описывает вычисления, которые никогда не дают значения — бесконечный цикл, return, panic!(), вызов std::process::exit. Теоретики типов знают эту сущность очень давно: это нижний тип, ⊥ лямбда-исчисления, пустое множество, притаившееся в углу вашей решётки типов. Пользователи Haskell знакомы с ним как Void. Rust ходит вокруг него с самой версии 1.0, а чтобы наконец стабилизировать, понадобилось десять лет и пять неудачных попыток.
Почему это так сложно? Потому что ! может приводиться к любому другому типу, и в этом вся его сила, а каждая точка приведения — это место, где вывод типов, разрешение трейтов и проверка исчерпывающности должны договориться между собой. Поскольку ветка match, которая расходится, имеет тип !, вот такой код компилируется:
fn infallible_unwrap<T>(res: Result<T, !>) -> T {
// ^^ naming `!` in a type position like this
// was not allowed on stable before 1.100
let Ok(v) = res;
v
}
Строка let Ok(v) = res; и есть награда: так как Err(!) не может существовать, компилятор принимает неопровержимый образец, и целая категория защитных вызовов unreachable!() исчезает. Вдобавок старый enum std::convert::Infallible становится алиасом типа для !, так что все API, написанные под Infallible за последние годы, автоматически совместимы с настоящим never-типом. Такое объединение было планом с самого начала, и именно поэтому стабилизация постоянно откладывалась: смена алиаса требовала изменить фоллбэк never-типа в редакциях до 2024 года, а это техническое ломающее изменение.
Посмотрите, как команда справилась с этим разрывом, потому что в нём вся философия в миниатюре. Они заранее выпустили предупреждения о совместимости с будущими версиями, протестировали экосистему через crater и заранее отправили исправления в публичные крейты, которые затронуло бы изменение. Ломающее изменение, выполненное в несколько циклов релизов, с измеренным и исправленным радиусом поражения до того, как большинство пользователей что-либо заметили. Сравните с обычным для индустрии ходом: поднять мажорную версию и пожать плечами. Я уже писал о том, к чему обязывает Rust его soundness, и история с never-типом это та же обязанность, но на уровне процесса. Когда ваша гарантия звучит как «безопасный код не может вызвать неопределённое поведение», даже тип без единого значения должен заслужить право на вход.
Кастомные аллокаторы наконец получают стабильную основу
Почти так же долгожданное: ядро работы над allocator_api стабилизировано. Трейт Allocator, Global, System и конструкторы *_in, такие как Vec::new_in, Vec::with_capacity_in, Box::new_in и Box::from_raw_in, теперь доступны на стабильном Rust. Авторы библиотек могут определить аллокатор и передать его стандартным коллекциям:
use std::alloc::{Allocator, Global};
// A Vec that allocates from your arena/pool/slab instead of the heap
let mut v: Vec<u64, _> = Vec::new_in(MyArena::new());
v.push(42);
Если вы писали только прикладной код, это может показаться сантехникой. Так и есть, и именно в сантехнике системные языки либо живут, либо умирают. До сих пор замена аллокаторов означала грубый инструмент #[global_allocator]: один аллокатор на весь процесс. Это нормально, когда вы хотите jemalloc или mimalloc везде (и реальная производительность на кону, ведь jemalloc заслужил репутацию на масштабе), но бесполезно, когда нужен один Vec поверх арены, которая освобождается одним махом в конце запроса, пока всё остальное использует стандартную кучу. Игровые движки, базы данных, встраиваемые системы с несколькими областями RAM, код рядом с ядром: всем им нужен контроль на уровне отдельных коллекций, и нужен он давно.
Обратите внимание на формулировку в самом релизе: это явно основа цели проекта «Allocators 1.0», а больше коллекций и типов указателей будут добавлены позже. Проект Rust научился спокойно говорить: «вот стабильное ядро, остальное намеренно остаётся в nightly». Такая последовательность (стабилизировать трейт и дизайн, дать экосистеме строиться на этом, расширять поверхность позже) как раз и позволяет не загнать себя в угол API, который придётся поддерживать вечно. C++ пошёл противоположным путём с std::allocator в девяностых: выпустил полуготовым и десятилетиями обходил последствия. Терпение обходится дешевле.
DropGuard: defer из Go, но в духе Rust
Неожиданный хит релиза — std::mem::DropGuard. Трейт Drop в Rust уже гарантирует, что код очистки выполнится, когда значение выходит из области видимости: при return, ?, панике, неважно. Но писать целый новый тип только ради запуска замыкания при выходе — это бойлерплейт, на который большинство из нас ворчало. DropGuard оборачивает значение и замыкание, разыменовывается в значение, так что с ним можно работать как обычно, и выполняет замыкание, когда страж умирает. Метод dismiss() его обезвреживает. Каноническое применение — откат транзакции:
use std::mem::DropGuard;
use std::num::ParseIntError;
/// Push every parsed string into `nums`, or leave `nums` untouched.
fn parse_all(nums: &mut Vec<u32>, strings: &[&str]) -> Result<(), ParseIntError> {
let len = nums.len();
let mut nums = DropGuard::new(nums, move |nums| {
nums.truncate(len); // rollback on failure
});
for s in strings {
nums.push(s.parse()?); // `?` exits early; the guard truncates
}
DropGuard::dismiss(nums); // success: keep the values
Ok(())
}
Если это напоминает defer из Go, так и есть, но с важным отличием в том, где живёт гарантия. defer в Go — это оператор, привязанный к функции: он выполняется при возврате из функции и невидим для системы типов. DropGuard — это значение. Его можно переместить, сохранить, передать в другую область видимости, условно отключить. Корни здесь уходят в RAII из C++ и старый трюк Александреску с ScopeGuard из ранних дней современного C++, который делал то же самое с деструкторами и вызовом Dismiss(). Rust не изобрёл эту идею; он впитал двадцатилетний идиом из C++, придал ему семантику владения и поместил в core. Так и выглядит хорошая эволюция языка: не новизна, а перенос проверенных паттернов в стандартный словарь.

Создание ничего: типы нулевого размера, сделанные правильно
Глубже в заметках спрятана функция с названием, которое мне искренне нравится: std::mem::conjure_zst. Типы нулевого размера, такие как юнит-структуры и маркерные токены вроде Python<'py из PyO3, повсюду в типовом программировании на Rust. Если инхабитед-тип не имеет размера, в нём может храниться ровно одно значение, так что его создание в каком-то смысле всегда «безопасно». Но API регулярно полагаются на то, что такие токены нельзя подделать: если призвать Python<'py из ниоткуда, безопасный код сможет притвориться, что держит GIL. Раньше ZST создавали через transmute из () или заклинания с MaybeUninit, и у каждого был свой тонкий смысл для ещё не определённых рекомендаций по unsafe-коду. Теперь есть одно признанное, громко помеченное unsafe написание. Это крошечная функция, которая существует затем, чтобы большой вопрос спецификации получил один аудируемый ответ. Скучно, аккуратно, правильно: весь релиз в одном API.
Cooldown зависимостей в Cargo: защита цепочки поставок по таймеру
Самое значимое изменение в 1.100, возможно, вообще не в языке. Cargo теперь поддерживает разрешение зависимостей с учётом min-publish-age, то есть cooldown зависимостей. Идея за этим эмпирическая: вредоносные версии пакетов обычно выявляются в течение нескольких часов или дней после публикации, сканерами или людьми. Поэтому можно просто отказаться разрешать версии, которые моложе настроенного окна:
# .cargo/config.toml
[registry]
global-min-publish-age = "3 days"
С этого момента cargo update тихо пропускает свежие релизы и сообщает, что придержал, например: clap 4.6.7 (available: 4.6.9, published 2 days ago). Когда вам действительно нужен срочный фикс, одноразовая переменная окружения позволяет подтянуть его осознанно, и этот выбор фиксируется в Cargo.lock, а не распространяется молча. Это редкий механизм безопасности, который почти ничего не стоит: вы меняете несколько дней свежести на постоянный карантин против всех быстро обнаруживаемых zero-day атак на пакеты. Учитывая, что мы наблюдали в других реестрах, компрометация LiteLLM на PyPI недавно стала отличным примером того, как быстро распространяется отравленный релиз, и cooldown это самая дешёвая страховка в экосистеме. Заметки к релизу честно признают, что это не полная защита, а cargo install обходит её полностью. Поддержка карантина и автоматическое обнаружение подозрительных релизов всё ещё в дорожной карте crates.io. Эшелонированная защита, внедряемая по одному слою за раз.
Гигиена сборки: неиспользуемые зависимости и коллизии кэша
Два улучшения качества жизни заслуживают упоминания, потому что бьют по двум самым частым жалобам в любом треде о Rust: время компиляции и занятое место на диске. Во-первых, Cargo теперь напрямую сообщает о неиспользуемых зависимостях, с предупреждением, которое указывает на точную строку в вашем Cargo.toml. У rustc давно есть линт unused_crate_dependencies, но с Cargo он давал ложные срабатывания, потому что зависимости разделяются между целями сборки: зависимость, которую использует один bin в пакете, выглядит неиспользуемой для другого. У Cargo есть глобальный взгляд, которого нет у rustc, так что предупреждение теперь живёт там, где живёт правда. Оно работает при сборке всех релевантных целей, и это первый представитель совершенно новой системы линтов [lints.cargo] для самого манифеста.
Во-вторых, перестроили директорию сборки. Разные конфигурации сборки, то есть наборы фич и профили, дают разные артефакты, и хеш конфигурации держит их раздельно. Этот хеш применялся непоследовательно из-за ограничений платформ, что приводило к лишним пересборкам, пропущенным пересборкам и общей путанице, а при общей директории сборки между git worktrees всё становилось хуже. Исправление переносит хеш из имён файлов в структуру директорий, организованную по шагам сборки. Незаметно, когда работает, и в этом и есть смысл, а ещё это открывает путь к сборке мусора кэша и дедупликации между workspace. Если ваш target/ когда-либо съедал 90 гигабайт и вынуждал ежедневный cargo clean, фундамент для вашего спасения только что заложили. Полное исправление ещё не здесь, но несущий рефакторинг уже готов.

Что сотня релизов учит об эволюции языка
Стабильность — это не отсутствие изменений. Это дисциплина в выстраивании последовательности изменений так, чтобы ничей код не платил за ваш роадмап.
Посмотрите на форму этого релиза. Уточнение теории типов, которое заняло десятилетие. Аллокаторный трейт, намеренно выпущенный как основа, а не готовая поверхность. Идиома scope-guard старше некоторых своих пользователей, наконец стандартизированная. Функция безопасности, построенная на метаданных реестра и честных оговорках. Внутренности системы сборки, отрефакторенные, чтобы разблокировать будущую работу. Ни одно из этого не является громким парадигмальным сдвигом, но вместе они составляют именно такой сдвиг: язык, который становится глубже, не становясь для вас другим. Та же тихая накопительная динамика видна в неэффектном продвижении Java, ещё одной экосистеме, которая поняла, что скучность, это тоже фича.
Механизмы, которые это делают возможным, заслуживают не меньше признания, чем любая фича. Модель поездов с шестинедельным циклом означает, что ни одна стабилизация никогда не становится экстренной. Crater, инструмент, который компилирует практически всю публичную экосистему крейтов с кандидатом компилятора, превращает вопрос «кого это сломает?» из молитвы в измерение. Редакции дают путь миграции по выбору, так что язык может менять свои значения по умолчанию, не меняя ваш код. А относительно новый институт именованных целей проекта (Allocators 1.0, раскладка директории сборки, укрепление цепочки поставок crates.io) даёт многолетним усилиям публичный стержень, так что такая фича, как never-тип, может провалиться пять раз и всё равно иметь обозначенный путь к финишу, а не умереть в ветке рассылки.
Урок здесь для всех, кто поддерживает платформу, протокол или широко используемую библиотеку. Пользователи не видят ваш роадмап; они видят ваши диффы. То, что never-тип появился в 1.100, а не в 1.35, это не история о медлительности, а история о том, что бывает, когда проект десятилетие считает «узнаем, когда увидим» приемлемым ответом. Большинство software-организаций не может позволить себе такого терпения, и, честно говоря, большинству оно и не нужно. Но если вы создаёте то, на чём другие строят свои системы, расчёт меняется: доверие пользователей растёт как проценты, и заработать его можно только сотней релизов, где ничего не ломается. Rust 1.100 — большой релиз, но главная история в том, что его можно установить, не читая заметки.


