Open source
System Programming
Rust

Выпуск Rust 1.35.0: Реализации функциональных трейтов и прочие новшества

Представляю вашему вниманию перевод публикации о новой версии всеми любимого языка программирования Rust.


Введение


Команда по разработке языка программирования Rust рада анонсировать новую версию, 1.35.0. Rust — это язык программирования, позволяющий каждому разрабатывать надёжное и быстрое ПО.


Если предыдущую версию Rust вы установили средствами rustup, получение текущей версии не составит особого труда:


$ rustup update stable

Если у вас всё ещё нет rustup, вы можете получить его с соответствующей страницы на нашем сайте. Детальный обзор данного релиза доступен на GitHub.


Что вошло в стабильную версию?


Главными новшествами этого релиза можно назвать реализации трейтов FnOnce, FnMut и Fn на структурах Box<dyn FnOnce>, Box<dyn FnMut> и Box<dyn Fn> соответственно.


А также встраиваемые функции (closures) могут быть сконвертированы в небезопасные указатели на функции. Макрос dbg!, введённый в Rust 1.32.0, теперь может быть вызван без указания аргументов.


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


Fn* трейты реализованы на Box<dyn Fn*>


В Rust 1.35.0 трейты FnOnce, FnMut и Fn реализованы на Box<dyn FnOnce>, Box<dyn FnMut> и Box<dyn Fn> соответственно.


В прошлом если вы желали вызвать функцию, инкапсулированную в Box<T>, вам необходимо было воспользоваться FnBox, так как объекты Box<dyn FnOnce> и подобные не реализовывали соответствующие трейты Fn*. Это также мешало передаче инкапсулированных в Box<T> функций коду, ожидавшему реализатор трейта Fn (предлагалось создавать временные встраиваемые функции).


Это было вызвано неспобностью компилятора обнаруживать подобные реализации. Этот недостаток был устранён с введением unsized_locals.


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


fn foo(x: Box<dyn Fn(u8) -> u8>) -> Vec<u8> {
    vec![1, 2, 3, 4].into_iter().map(x).collect()
}

Объекты Box<dyn FnOnce> могут быть вызваны без лишней возни:


fn foo(x: Box<dyn FnOnce()>) {
    x()
}

Конвертация в небезопасные указатели


Со времен Rust 1.19.0 стало возможным конвертирование встраиваемых функций, не захватывавших среду в указатели на функции. Например, вы могли написать:


fn twice(x: u8, f: fn(u8) -> u8) -> u8 {
    f(f(x))
}

fn main() {
    assert_eq!(42, twice(0, |x| x + 21));
}

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


/// Безопасные инварианты, переданные в `unsafe fn`.
unsafe fn call_unsafe_fn_ptr(f: unsafe fn()) {
    f()
}

fn main() {
    // БЕЗОПАСНОСТЬ: тут нет никаких инвариантов
    // Данная функция статически предотвращена от небезопасных
    // операций
    unsafe {
        call_unsafe_fn_ptr(|| {
            dbg!();
        });
    }
}

Вызов dbg!() без аргументов


Вследствие обилия вызовов println! в качестве колхозных дебаггеров, в Rust 1.32.0 был представлен макрос dbg!. Напомним, что данный макрос позволяет быстро запечатлить результат некого выражения с контекстом:


fn main() {
    let mut x = 0;

    if dbg!(x == 1) {
        x += 1;
    }

    dbg!(x);
}

Приведённые выше строки кода напечатают в терминал результат выражения x == 1 и x соответственно:


[src/main.rs:4] x == 1 = false
[src/main.rs:8] x = 0

Как было сказано в предыдущей секции, где может быть вызвана функция высшего порядка call_unsafe_fn_ptr, dbg!() также подлежит вызову без указания аргументов. Это может быть крайне полезно для обнаружения выбранных программных веток:


fn main() {
    let condition = true;

    if condition {
        dbg!(); // [src/main.rs:5]
    }
}

Стабилизации стандартной библиотеки


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


Копирование знака числа с плавающей точкой в другое число


С данным релизом новые методы copysign были добавлены в примитивы с плавающей точкой (конкретнее, f32 и f64):



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


fn main() {
    assert_eq!(3.5_f32.copysign(-0.42), -3.5);
}

Проверка того, содержит ли Range определённое значение


Rust 1.35.0 приобрёл парочку новых методов на структурах Range*:



С помощью данных методов вы можете с лёгкостью проверить, находится ли определённое значение в диапазоне. Например, вы можете написать:


fn main() {
    if (0..=10).contains(&5) {
        println!("5 находится в диапазоне [0; 10].");
    }
}

Перевести (map) и разбить (split) заимствованный RefCell


С приходом Rust 1.35.0 вы можете перевести и разбить заимствованное значение RefCell на множество заимствованных значений на разные компоненты заимствованных данных:



Переставить значение RefCell через встраиваемую функцию


Этот релиз представляет удобный метод replace_with, объявленный на структуре RefCell:



Хешировать указатель или ссылку по адресу


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


Копирование контента Option<&T>


С началом Rust 1.0.0 методы Option::cloned на Option<&T> и Option<&mut T> позволяли клонировать содержание в случае его присутствия (Some(_)). Однако клонирование иногда может быть дорогостоящей операцией, а методы opt.cloned() не описывали никаких подсказок.


Этот релиз внёс:



Функциональность opt.copied() такая же, как и opt.cloned(). Однако описанный выше метод запрашивает условия T: Copy, невыполнение которого вызвет ошибку компиляции.


Изменения в Clippy


Clippy, инструмент, отлавливающий часто встречаемые несовершенности для повышения качества кода, обзавёлся drop_bounds. Оно срабатывает в тех случаях, когда обобщённая функция запрашивает выполнения условия T: Drop:


fn foo<T: Drop>(x: T) {}

Это часто является ошибкой, так как примитивы не реализуют Drop. Более того, T: Drop не покрывает типы, подобные String, не имеющие наглядного поведения деструктора, а скорее результат встраиваемых типов (как Vec<u8>).


В дополнение к drop_bounds, данный релиз разделяет redundant_closure в redundant_closure и redundant_closure_for_method_calls.


Прочесть детальный релиз Clippy можно тут.


Изменения в Cargo


Детальное описание изменений Cargo доступно здесь.


Участники 1.35.0


Множество людей собрались вместе, чтобы создать Rust 1.35.0. Мы не смогли бы сделать это без всех вас, спасибо!


От переводчика


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

+32
4.3k 17
Support the author
Comments 14
Top of the day