Без примеров невозможно ни правильно учить, ни успешно учиться (Л. Колумелла).

Rust 1.100.0: стабилизация never type, пользовательские аллокаторы и новые возможности Cargo


Rust 1.100.0: стабилизация never type, пользовательские аллокаторы и новые возможности Cargo

12 ноября 2026 года команда Rust выпустила стабильную версию языка Rust 1.100.0. Обновление содержит несколько важных изменений, затрагивающих систему типов, управление памятью, стандартную библиотеку и пакетный менеджер Cargo. Среди наиболее заметных нововведений — окончательная стабилизация never type (`!`), развитие интерфейса пользовательских аллокаторов, появление `DropGuard`, а также инструменты для контроля зависимостей и повышения безопасности цепочки поставок программного обеспечения.

Rust 1.100.0 нельзя назвать революционным обновлением, которое меняет привычный стиль разработки. Скорее, это последовательное развитие уже существующих механизмов. Некоторые возможности, которые долго находились в экспериментальном состоянии, теперь становятся частью стабильного языка. Другие направлены на решение практических проблем: лишние зависимости замедляют сборку, кэш Cargo может конфликтовать между конфигурациями проектов, а недавно опубликованные версии пакетов иногда оказываются вредоносными.

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

Официальное объявление опубликовано в блоге Rust: Announcing Rust 1.100.0. Полный перечень изменений доступен также в официальных примечаниях к выпускам Rust.

 

Never type (!) наконец стал стабильным

Одно из главных событий Rust 1.100.0 — стабилизация never type, обозначаемого символом `!`. Работа над этой возможностью продолжалась около десяти лет и сопровождалась несколькими неудачными попытками стабилизации. Теперь тип стал полноценной частью стабильного языка и может использоваться не только в типах возвращаемых значений функций.

Never type представляет вычисление, которое никогда не завершается обычным результатом. Иными словами, выражение типа `!` не может предоставить значение, после которого выполнение программы продолжится стандартным образом.

К таким операциям относятся:

  • `return` — завершает выполнение текущей функции и возвращает управление вызывающему коду;
  • `break` — прерывает выполнение цикла или другого соответствующего блока;
  • `panic!()` — вызывает аварийное завершение текущего потока выполнения, если паника не перехвачена соответствующим механизмом;
  • `std::process::exit()` — завершает процесс программы;
  • бесконечный цикл без условия выхода.

 

Рассмотрим простой пример:

fn terminate_program() -> ! {
    std::process::exit(1);
}

 

Функция объявлена с возвращаемым типом `!`, потому что после вызова `std::process::exit()` она не возвращает обычное значение. Это помогает компилятору точнее анализировать поток выполнения и проверять корректность программы.

Особенно полезно поведение never type при работе с `match` и условными выражениями. Например:

fn get_value(option: Option<u32>) -> u32 {
    match option {
        Some(value) => value,
        None => return 0,
    }
}

 

В одной ветви возвращается число типа `u32`, а в другой выполнение функции завершается. Поскольку `return` имеет тип `!`, Rust может преобразовать его в ожидаемый тип выражения. Такое преобразование называется never-to-any coercion: значение, которое никогда не будет получено, может быть приведено к необходимому типу.

Главное новшество Rust 1.100 заключается в том, что теперь `!` разрешено явно указывать в гораздо большем количестве позиций системы типов. Например:

fn infallible_unwrap<T>(res: Result<T, !>) -> T {
    let Ok(value) = res;
    value
}

 

Здесь `Result<T, !>` означает, что операция может завершиться успешным результатом типа `T`, но не может вернуть ошибку. Тип `!` не имеет допустимых значений, поэтому ветка с ошибкой в такой конструкции невозможна.

Одновременно `std::convert::Infallible` теперь становится псевдонимом never type. Это делает систему типов более последовательной и упрощает взаимодействие старых API с новым обозначением `!`.

 

Изменение совместимости: на что обратить внимание при обновлении

Стабилизация never type потребовала изменения поведения компилятора, которое может затронуть некоторые существующие проекты. В редакциях Rust 2015, 2018 и 2021 изменён механизм never type fallback: вместо `()` теперь используется `!`. В редакции 2024 аналогичное поведение было введено ранее.

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

Например, библиотека, которая раньше полагалась на автоматическое выведение типа `()`, может столкнуться с новыми предупреждениями или ошибками. Компилятор также способен обнаруживать больше недостижимого кода.

Команда Rust заранее предупреждала разработчиков о предстоящем изменении и публиковала предупреждения совместимости. Тем не менее перед обновлением крупного проекта желательно проверить все зависимости и прогнать полный набор тестов.

Если после перехода на Rust 1.100 перестала собираться сторонняя библиотека, стоит сначала проверить наличие более свежей версии этой зависимости. В некоторых популярных пакетах исправления уже могли появиться.

 

Allocator API: пользовательские аллокаторы становятся стабильными

Второе крупное изменение касается управления памятью. Rust 1.100 стабилизирует основную часть интерфейса `allocator_api`, позволяя разработчикам создавать собственные аллокаторы и использовать их с некоторыми типами стандартной библиотеки.

Аллокатор — компонент, отвечающий за выделение и освобождение памяти. В обычном Rust-приложении разработчик чаще всего не взаимодействует с ним напрямую: стандартные коллекции и типы вроде `Vec` и `Box` используют привычные механизмы управления памятью.

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

Стабилизированный интерфейс основан на трейте `Allocator`. Он позволяет описывать собственные механизмы выделения памяти и передавать их некоторым стандартным контейнерам.

В Rust 1.100 поддержка пользовательских аллокаторов распространяется, в частности, на:

  • `Vec` — динамические массивы;
  • `Box` — указатели на данные, размещённые в куче;
  • `Rc` — типы с подсчётом ссылок для однопоточного использования;
  • `Arc` — типы с атомарным подсчётом ссылок для многопоточных сценариев.

 

Также стабилизированы методы создания контейнеров с указанием аллокатора, включая `Vec::new_in`, `Vec::with_capacity_in` и `Box::new_in`.

Это важный шаг для проекта Allocators 1.0. При этом команда Rust подчёркивает, что работа ещё не завершена. В дальнейшем планируется расширить набор типов стандартной библиотеки, которые смогут работать с пользовательскими аллокаторами.

Для обычных приложений переход на новые API необязателен. Но разработчики библиотек и системных компонентов получают больше возможностей для управления памятью без необходимости полностью отказываться от стандартных контейнеров Rust.

 

DropGuard: выполнение кода при любом выходе из области видимости

В стандартной библиотеке появился новый тип `core::mem::DropGuard`. Он предназначен для выполнения замыкания при уничтожении объекта, то есть при выходе из соответствующей области видимости.

В Rust уже существует трейт `Drop`, который позволяет определить действия при уничтожении значения. Он широко применяется для освобождения ресурсов, закрытия соединений, освобождения блокировок и других операций, которые должны выполняться независимо от того, каким образом завершилась функция.

Однако иногда разработчику не требуется создавать отдельный тип и реализовывать для него `Drop`. Достаточно выполнить небольшое действие при выходе из функции. Именно такую задачу упрощает `DropGuard`.

Он принимает значение и замыкание, которое будет вызвано при уничтожении защитного объекта. При этом `DropGuard` реализует `Deref` и `DerefMut`, поэтому с исходным значением можно продолжать работать почти так же, как раньше.

Особенно полезен механизм для операций, которые должны либо завершиться полностью, либо откатить внесённые изменения.

Пример из официального объявления демонстрирует разбор нескольких строк в числа с сохранением исходного состояния вектора при ошибке:

use std::mem::DropGuard;
use std::num::ParseIntError;

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);
    });

    for s in strings {
        nums.push(s.parse()?);
    }

    DropGuard::dismiss(nums);
    Ok(())
}

 

Логика здесь следующая:

  1. Сохраняется исходная длина вектора.
  2. Создаётся `DropGuard`, который при уничтожении вернёт вектор к прежней длине.
  3. Строки преобразуются в числа и добавляются в вектор.
  4. Если преобразование завершится ошибкой, оператор `?` вернёт управление, а защитный объект выполнит откат.
  5. Если все операции прошли успешно, `DropGuard::dismiss` отключит защитное действие и вернёт исходное значение.

 

Такой подход напоминает транзакционный механизм: изменения либо сохраняются после успешного выполнения, либо отменяются при ошибке. Это удобно для парсеров, преобразования данных и других операций, в которых важно не оставлять частично изменённое состояние.

При этом `DropGuard` не заменяет полноценные транзакции баз данных или сложные механизмы отката. Он предоставляет инструмент на уровне управления временем жизни объектов и позволяет компактнее реализовывать локальную логику очистки.

 

conjure_zst: новый способ создания типов нулевого размера

В Rust 1.100 появилась функция `std::mem::conjure_zst`, предназначенная для создания значений типов нулевого размера (Zero-Sized Types, ZST).

Типы нулевого размера не занимают места в памяти в обычном смысле. К ним относятся, например, пустые структуры и некоторые маркерные типы, используемые для выражения ограничений и состояний в системе типов.

До появления специализированной функции разработчики могли использовать различные низкоуровневые приёмы, например `transmute` или `MaybeUninit::uninit().assume_init()`. Такие конструкции требуют особой осторожности и могут быть небезопасными, если тип имеет дополнительные условия создания.

Новая функция предоставляет более явный способ получить значение ZST, когда разработчик уже гарантировал безопасность такой операции.

Однако `conjure_zst` является небезопасной функцией. Причина заключается в том, что некоторые типы нулевого размера используются не просто как маркеры, а как подтверждение определённого состояния программы.

Например, библиотека PyO3 использует тип `Python<‘py>` для представления владения глобальной блокировкой интерпретатора Python (GIL). Наличие такого значения означает, что вызывающий код соблюдает определённые условия безопасности. Если создать подобный маркер произвольно, можно нарушить предположения, на которых построены безопасные API библиотеки.

Следовательно, `conjure_zst` предназначена для случаев, когда создание значения действительно допустимо. Наличие нулевого размера само по себе не означает, что любой тип можно безопасно сконструировать без выполнения дополнительных условий.

 

Cargo теперь предупреждает о неиспользуемых зависимостях

В Rust 1.100 улучшена диагностика зависимостей в Cargo. Пакетный менеджер теперь способен предупреждать о подключённых библиотеках, которые не используются в проекте.

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

Ранее компилятор Rust уже имел lint `unused_crate_dependencies`, но при использовании Cargo он мог выдавать ложные срабатывания. Причина заключалась в том, что одна зависимость могла использоваться только отдельной программой или конкретной целью сборки внутри одного пакета.

Например, в проекте может быть несколько исполняемых файлов. Библиотека `tracing-subscriber` подключена на уровне всего пакета, но используется только одним из бинарных файлов. Проверка одного конкретного target не должна объявлять зависимость лишней, если другой target действительно её использует.

Теперь Cargo вводит собственную систему предупреждений. Например, при обнаружении ненужной зависимости можно получить сообщение следующего вида:

warning: unused dependency `tracing-subscriber`
  --> Cargo.toml:23:1
   |
23 | tracing-subscriber.workspace = true
   | ^^^^^^^^^^^^^^^^^^
   |
   = note: `cargo::unused_dependencies` is set to `warn` by default
   help: consider removing the dependency on `tracing-subscriber`

 

Предупреждение управляется через новую систему lint-настроек Cargo в таблице `[lints.cargo]` файла `Cargo.toml`.

Есть и ограничение: для корректной проверки Cargo должен собрать все цели, которые могут использовать зависимости из соответствующей секции. Например, команда `cargo check —bin foo` не обязательно обнаружит неиспользуемую зависимость, если другой бинарный файл в том же пакете её применяет. Для `dev-dependencies` аналогичные предупреждения также ограничены возможностями определения всех сценариев разработки.

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

 

Cargo min-publish-age: защита от слишком свежих версий пакетов

Одним из наиболее интересных изменений Rust 1.100 стала стабилизация механизма `min-publish-age` в Cargo. Его задача — снизить риск установки вредоносной версии зависимости, опубликованной совсем недавно.

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

Механизм dependency cooldowns предлагает не устанавливать самые свежие версии немедленно, а выдерживать определённую паузу после публикации. Это даёт время для обнаружения подозрительных изменений и реакции сопровождающих пакета.

Включить ограничение можно через файл `.cargo/config.toml`:

[registry]
global-min-publish-age = "3 days"

 

После этого Cargo при выборе версий будет учитывать дату публикации. Если совместимая версия вышла слишком недавно, менеджер пакетов может выбрать более старую версию, которая уже прошла заданный период ожидания.

При обновлении можно увидеть сообщение примерно следующего вида:

Updating crates.io index
Locking 2 packages to highest compatible version as of min-publish-age
Adding cc v1.11.0 (available: v1.18.0, published 3 hours ago)
Adding clap 4.6.7 (available: 4.6.9, published 2 days ago)

 

В этом примере Cargo не выбирает самые свежие версии, поскольку они ещё не достигли установленного возраста. Вместо них используются более ранние совместимые релизы.

Если новая версия необходима немедленно, проверку можно переопределить для отдельной операции обновления с помощью переменной окружения:

CARGO_RESOLVER_INCOMPATIBLE_PUBLISH_AGE=allow \
cargo update clap --precise 4.6.9

 

Такой подход позволяет сочетать осторожную политику обновления с возможностью вручную принять решение об установке свежего релиза.

У механизма есть несколько ограничений:

  • Проверка зависит от наличия информации о времени публикации версии в индексе реестра.
  • `cargo install` не применяет ограничение минимального возраста публикации ни к устанавливаемому пакету, ни к его зависимостям.
  • Если требуется установить конкретную версию через `cargo install`, можно явно указать её номер.
  • Период ожидания не гарантирует обнаружение всех вредоносных пакетов и не заменяет проверку обновлений.

 

Например, установка конкретной версии выполняется так:

cargo install foo@1.2.3

 

Особенно важно понимать, что `min-publish-age` — дополнительный уровень защиты, а не полноценная система анализа безопасности. Если вредоносная версия останется незамеченной дольше установленного периода, она всё равно может попасть в проект. Поэтому разработчикам необходимо продолжать проверять изменения зависимостей, использовать блокировку версий и анализировать содержимое обновлений.

Команда Rust рассматривает этот механизм как часть более широкой инициативы по укреплению безопасности экосистемы crates.io. Среди дальнейших направлений работы упоминаются карантин подозрительных публикаций и автоматическое обнаружение потенциально вредоносных релизов.

 

Улучшение структуры кэша сборки Cargo

Ещё одно изменение касается внутренней организации каталогов сборки. Cargo использует отдельные директории для промежуточных и конечных артефактов, но ранее некоторые конфигурации могли приводить к конфликтам кэша.

Проблема особенно заметна при использовании разных наборов функций, конфигураций сборки и нескольких Git worktree. Один и тот же проект может собираться с различными параметрами, а промежуточные библиотеки и исполняемые файлы должны оставаться строго разделёнными.

Для идентификации вариантов сборки Cargo использует хеш конфигурации. Однако ранее он не всегда применялся ко всем файлам из-за ограничений платформ и особенностей структуры каталогов. Это могло приводить к лишним пересборкам, пропущенным пересборкам и путанице относительно того, какие именно библиотеки используются.

В Rust 1.100 Cargo последовательно применяет хеш конфигурации к содержимому `build-dir`. Вместо размещения идентификатора в имени отдельного файла он переносится в структуру родительских каталогов, организованных вокруг этапов сборки.

Это внутреннее изменение не добавляет разработчику новую команду, но создаёт основу для дальнейших улучшений:

  • более эффективной очистки устаревших элементов кэша;
  • уменьшения дублирования данных между рабочими пространствами;
  • совместного использования кэша разными проектами;
  • более точной блокировки операций при параллельной сборке.

 

При этом обновление может затронуть некоторые пользовательские сценарии сборки, особенно если они использовали обходные решения для прежней структуры каталогов. Разработчикам таких инструментов рекомендуется проверить скрипты и тесты после обновления Cargo.

 

Другие изменения языка, компилятора и стандартной библиотеки

Помимо крупных нововведений, Rust 1.100 содержит ряд дополнительных улучшений. Они затрагивают диагностику, взаимодействие с внешними интерфейсами и API стандартной библиотеки.

Среди изменений языка выделяется стабилизация `extern «custom»`. Это расширяет возможности описания внешних ABI и взаимодействия с кодом, написанным на других языках или использующим нестандартные соглашения о вызовах.

Также компилятор теперь предупреждает о повторном использовании атрибутов `#[repr(…)]` в соответствующих случаях. Дополнительно расширены проверки, связанные с некорректным использованием `drop_in_place`, а некоторые ошибки, связанные с сочетанием `repr(packed)` и выравнивания полей, переведены в категорию предупреждений, запрещённых по умолчанию.

В компиляторе стабилизирован параметр `-Cprofile-sample-use`, связанный с использованием профилей при оптимизации кода. Это важно для сценариев Profile-Guided Optimization (PGO), когда компилятор может учитывать сведения о реальном поведении программы при выборе оптимизаций.

В области поддержки платформ цель `i686-pc-windows-gnu` получила статус Tier 2 без host tools. Это означает изменение уровня поддержки конкретной целевой платформы, но не следует трактовать его как полную гарантию одинакового качества всех инструментов и сценариев разработки.

В стандартной библиотеке также стабилизированы многочисленные методы и реализации трейтов. Среди них:

  • `bool::toggle` — переключение логического значения;
  • `Box::take`, `Box::map`, `Rc::map` и `Arc::map` — дополнительные операции с типами указателей;
  • `str::trim_prefix` и `str::trim_suffix` — удаление заданных префиксов и суффиксов строк;
  • `Vec::from_fn` — создание вектора с использованием функции генерации элементов;
  • `UnsafeCell::replace` и новые методы доступа к содержимому `UnsafeCell`;
  • дополнительные API для работы с аллокаторами и управления процессами в Windows.

 

Полный список стабилизированных API и изменений доступен в официальном объявлении Rust 1.100.0 и в примечаниях к версии 1.100.0.

 

Как обновиться до Rust 1.100.0

Разработчикам, которые устанавливают Rust через rustup, достаточно обновить стабильный канал. Для этого выполните в терминале:

rustup update stable

 

После завершения обновления проверить установленную версию можно командой:

rustc --version
cargo --version

 

Если Rust установлен через системный пакетный менеджер Linux или другой способ, порядок обновления будет зависеть от используемого дистрибутива и источника пакетов. В таком случае следует проверить доступность Rust 1.100.0 в соответствующем репозитории или воспользоваться официальным способом установки.

Для проверки существующего проекта после обновления рекомендуется выполнить:

cargo check
cargo test
cargo clippy

 

Если проект использует пользовательские скрипты сборки, нестандартные конфигурации Cargo или библиотеки с обобщёнными типами, стоит дополнительно проверить их совместимость с изменением never type fallback и новой структурой кэша.

Разработчики, желающие заранее тестировать будущие изменения, могут переключиться на beta- или nightly-канал. Однако такие версии не следует без необходимости использовать для производственных сборок.

 

Выводы

Rust 1.100.0 — важный технический релиз, который делает язык и его инструменты более зрелыми. Наиболее заметное изменение — стабилизация never type, над которой команда работала около десяти лет. Теперь разработчики могут полноценно использовать `!` в системе типов, а `Infallible` становится его псевдонимом.

Стабилизация основных частей `Allocator API` расширяет возможности управления памятью и создаёт фундамент для более гибкой работы стандартных контейнеров. Новый `DropGuard` упрощает реализацию действий при выходе из области видимости и позволяет компактно создавать механизмы отката изменений при ошибках.

Не менее важны изменения Cargo. Предупреждения о неиспользуемых зависимостях помогают поддерживать чистоту проектов, улучшенная структура кэша снижает вероятность конфликтов между конфигурациями сборки, а `min-publish-age` добавляет полезную защиту от слишком свежих и потенциально вредоносных версий пакетов.

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

Главный вывод: Rust 1.100.0 не просто добавляет новые API, а укрепляет несколько фундаментальных направлений экосистемы — безопасность типов, управление ресурсами, производительность сборки и защиту цепочки поставок программного обеспечения.

 

Часто задаваемые вопросы

Стабильная версия Rust 1.100.0 была выпущена 12 ноября 2026 года. Официальное объявление опубликовано командой Rust в блоге проекта.

Одно из главных изменений — стабилизация never type (`!`). Теперь его можно явно использовать в большем количестве позиций системы типов, а `std::convert::Infallible` становится псевдонимом этого типа.

Он обозначает вычисление, которое не возвращает обычного значения. Например, завершение процесса, возврат из функции или вызов паники могут иметь тип `!`.

Это интерфейс для создания пользовательских аллокаторов памяти. В Rust 1.100 стабилизирована его основная часть, позволяющая использовать собственные механизмы выделения памяти с такими типами, как `Vec`, `Box`, `Rc` и `Arc`.

`DropGuard` выполняет заданное замыкание при уничтожении защитного объекта. Его можно использовать для очистки ресурсов или отката изменений, если операция завершилась ошибкой.

Она предназначена для создания значений типов нулевого размера. Функция является небезопасной, поскольку некоторые ZST используются как маркеры определённых условий безопасности, и произвольное создание таких значений может нарушить гарантии библиотек.

Это механизм задержки использования недавно опубликованных версий зависимостей. Он позволяет выдержать период ожидания, в течение которого сообщество или автоматические системы могут обнаружить вредоносное обновление.

Нет. Механизм снижает риск установки подозрительных свежих версий, но не заменяет аудит кода, проверку обновлений, блокировку зависимостей и другие меры безопасности.

Большинство проектов не требует специальной переработки. Однако изменение never type fallback может повлиять на отдельные участки обобщённого кода и сторонние библиотеки. После обновления рекомендуется выполнить проверку сборки и тесты.

Если Rust установлен через rustup, достаточно выполнить команду `rustup update stable`. После этого установленную версию можно проверить с помощью `rustc —version`.

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Редактор: AndreyEx

Если статья понравилась, поделитесь ей в социальных сетях

Оставить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Это может быть вам интересно


Спасибо!

Теперь редакторы в курсе.

Прокрутить страницу до начала