В Rust 1.100 стабилизировали тип never: три примера для тех, кто учит язык

Тип ! означает «сюда выполнение не дойдёт», и вы уже пользовались им в каждом match с return. Показываем три программы, собранные на Rust 1.100.0, и их вывод.
В Rust 1.100 стабилизировали тип never: три примера для тех, кто учит язык

12 ноября вышел Rust 1.100.0. Главное изменение в языке команда описывает так: после 10 лет и 5 неудачных попыток тип never наконец стал стабильным. В коде он записывается одним символом — !.

Для тех, кто учит Rust, это хороший повод разобраться с механизмом, который всё время был рядом. Тип ! стоит за каждым return, break, continue и panic!. Теперь его можно явно указать в любом месте, где ожидается тип. Ниже — три программы: мы собрали каждую компилятором 1.100.0 и приводим её вывод.

Что такое never в одном абзаце

У типа ! нет ни одного значения. Он описывает вычисление, которое не завершается результатом: функция вышла через return, цикл перешёл к следующему шагу, программа остановилась. Раз значения получить нельзя, компилятор разрешает подставить ! на место любого другого типа. В документации это называется приведением never-to-any. На нём держатся первые два примера.

Пример 1. Ветка match, которая ничего не возвращает

Программа складывает числа из строк и пропускает то, что числом не является:

        fn main() {
    let inputs = ["42", "abc", "7"];
    let mut sum = 0;
    for s in inputs {
        let n: i32 = match s.parse() {
            Ok(n) => n,
            // у `continue` тип `!`, поэтому ветка совместима с i32
            Err(_) => continue,
        };
        sum += n;
    }
    println!("сумма: {sum}");
}
    
        сумма: 49
    

Обе ветки match должны возвращать один тип. Первая даёт i32. Вторая не возвращает ничего: continue переводит выполнение к следующему шагу цикла. Его тип ! приводится к i32, и проверка типов проходит. Так работало и в старых версиях Rust, просто об этом редко говорят.

Пример 2. Функция, которая никогда не возвращается

Тип ! можно указать как возвращаемый. Так компилятор узнаёт, что после вызова функции выполнение не продолжится:

        fn fail(msg: &str) -> ! {
    eprintln!("ошибка: {msg}");
    std::process::exit(1)
}

fn main() {
    let port: u16 = match std::env::var("PORT") {
        Ok(v) => v.parse().unwrap_or_else(|_| fail("PORT должен быть числом")),
        Err(_) => 8080,
    };
    println!("порт: {port}");
}
    

Запуск без переменной окружения и с неверным значением:

        $ ./ex2
порт: 8080
$ PORT=abc ./ex2
ошибка: PORT должен быть числом
    

Во втором случае процесс завершается с кодом 1. Замыкание внутри unwrap_or_else должно вернуть u16, а возвращает результат fail, то есть !. Компилятор это принимает по тому же правилу, что и в первом примере. Запись -> ! работала и раньше.

Пример 3. Ошибка, которой не бывает

Здесь начинается новое. До версии 1.100 в стабильном Rust ! разрешалось писать только как возвращаемый тип функции. Теперь его можно использовать где угодно, например как тип ошибки в Result:

        trait Parse: Sized {
    type Error;
    fn parse(s: &str) -> Result<Self, Self::Error>;
}

struct Upper(String);

impl Parse for Upper {
    type Error = !; // до 1.100 на стабильном Rust так написать было нельзя

    fn parse(s: &str) -> Result<Self, !> {
        Ok(Upper(s.to_uppercase()))
    }
}

fn main() {
    // ветки Err не существует, поэтому хватает одного образца
    let Ok(Upper(text)) = Upper::parse("rust");
    println!("{text}");

    // Infallible теперь псевдоним `!`: старый API подходит под новый тип
    let same: Result<u8, !> = u8::try_from(200u8);
    let Ok(n) = same;
    println!("{n}");
}
    
        RUST
200
    

Типаж Parse требует от каждой реализации указать тип ошибки. Перевод строки в верхний регистр сломаться не может, и запись type Error = ! говорит об этом компилятору. Значение Result<Upper, !> всегда равно Ok: вариант Err пришлось бы создавать из значения типа !, а таких значений нет. Поэтому let Ok(...) = ... компилируется без unwrap и без ветки для ошибки.

Последние строки показывают второе изменение релиза. В стандартной библиотеке для таких случаев давно есть тип Infallible. Преобразование u8 в u8 через try_from возвращает ошибку именно этого типа. В 1.100 Infallible стал псевдонимом !, поэтому результат старой функции можно присвоить переменной с новым типом.

Как запустить у себя

Обновите компилятор и проверьте версию:

        rustup update stable
rustc --version
    

Наше окружение: rustc 1.100.0 (0ef1bc386 2026-11-09), Linux x86_64. Мы сохранили каждый пример в отдельный файл и собрали одной командой:

        rustc --edition 2024 ex3.rs && ./ex3
    

Для сравнения мы проверили те же файлы на более ранней версии, 1.99.0. Первые два примера скомпилировались, а третий остановился на строке с type Error = !:

        error[E0658]: the `!` type is experimental
 --> ex3.rs:9:18
  |
9 |     type Error = !; // до 1.100 на стабильном Rust так написать было нельзя
  |                  ^
    

Что может сломаться в старом коде

У этого изменения есть цена. Чтобы сделать Infallible псевдонимом, команде пришлось поменять правило вывода типов в редакциях 2015, 2018 и 2021: если тип, к которому приводится !, вывести не удалось, компилятор раньше подставлял (), а теперь подставляет !. В редакции 2024 так было с самого начала. Авторы релиза пишут, что в большинстве проектов это пройдёт незаметно, но в редких случаях код перестанет собираться. Например, так бывает при вызове функции, возвращающей обобщённый параметр, если её результат игнорируется. Ещё компилятор может начать помечать как недостижимые те участки, которые раньше не замечал.

Если после перехода на 1.100.0 не собирается зависимость, сначала обновите её: по словам команды, исправления для затронутых публичных крейтов выпустили заранее.

Что запомнить

  • ! — тип без значений. Он появляется там, где выполнение не доходит до результата.
  • Его можно подставить вместо любого типа, поэтому return, continue и panic! уместны в ветках match.
  • С версии 1.100 ! можно писать в любом месте, и Result<T, !> означает операцию, которая не может завершиться ошибкой.

Кроме типа never, в релиз вошли стабильное ядро API аллокаторов, DropGuard и защита Cargo от только что опубликованных версий зависимостей.

Источники

Комментарии

ЛУЧШИЕ СТАТЬИ ПО ТЕМЕ