Русский
Русский
English
Статистика
Реклама

Rustfmt

Перевод Rust 1.45.0 стабилизация функциональных процедурных макросов, исправление дефектов преобразования

18.07.2020 18:23:19 | Автор: admin

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


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


rustup update stable

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


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


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


Исправление дефектов в преобразованиях


Изначально Issue 10184 была открыта в октябре 2013 года, за полтора года до выпуска Rust 1.0. Так как rustc использует LLVM в качестве backend-компилятора, когда вы пишете подобный код:


pub fn cast(x: f32) -> u8 {    x as u8}

компилятор Rust в версиях 1.44.0 и раньше генерировал следующее LLVM-IR:


define i8 @_ZN10playground4cast17h1bdf307357423fcfE(float %x) unnamed_addr #0 {start:  %0 = fptoui float %x to i8  ret i8 %0}

fptoui реализует преобразование и является сокращением от "floating point to unsigned integer".


Но здесь есть проблема, описанная в документации:


Инструкция fptoui преобразовывает операнд с плавающей точкой в ближайшее (округляя до нуля) беззнаковое целое значение. Если значение не помещается в ty2, то результирующее значение будет испорченным.
Оригинал
The fptoui instruction converts its floating-point operand into the nearest (rounding towards zero) unsigned integer value. If the value cannot fit in ty2, the result is a poison value.

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


Это означает что, например, поведение следующего кода не определено:


fn cast(x: f32) -> u8 {    x as u8}fn main() {    let f = 300.0;    let x = cast(f);    println!("x: {}", x);}

На моём компьютере с Rust 1.44.0 этот код печатает "x: 0", но т.к. его поведение не определено, напечатать он может всё что угодно. Это мы называем ошибкой корректности (ведь unsafe кода тут нет) то есть ошибка, когда компилятор делает неправильные вещи. Мы отмечаем их в нашем трекере как I-unsound, и относимся к ним очень серьёзно.


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


В итоге было принято решение сделать так:


  • as будет выполнять "насыщающее приведение" (saturating cast),
  • будет добавлено новое unsafe приведение, если вы хотите пропустить проверки.

Это очень похоже на доступ к массиву, например:


  • array[i] проверит, чтобы убедиться, что array содержит по крайней мере i + 1 элемент,
  • можно использовать unsafe { array.get_unchecked(i) }, чтобы пропустить проверку.

Итак, что такое насыщающее приведение? Давайте посмотрим на слегка изменённый пример:


fn cast(x: f32) -> u8 {    x as u8}fn main() {    let too_big = 300.0;    let too_small = -100.0;    let nan = f32::NAN;    println!("too_big_casted = {}", cast(too_big));    println!("too_small_casted = {}", cast(too_small));    println!("not_a_number_casted = {}", cast(nan));}

Выведет:


too_big_casted = 255too_small_casted = 0not_a_number_casted = 0

То есть слишком большие числа превращаются в максимально возможное значение. Слишком малые числа дают наименьшее возможное значение (равное нулю). NaN выдаёт ноль.


А это новый API для небезопасного приведения:


let x: f32 = 1.0;let y: u8 = unsafe { x.to_int_unchecked() };

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


Стабилизация функциональных процедурных макросов в выражениях, шаблонах и стейтментах


В Rust 1.30.0 мы стабилизировали функциональные процедурные макросы в позиции элемента. Например, крейт gnome-class:


Gnome-класс это процедурный макрос для Rust. Внутри макроса мы определяем Rust-о подобный мини-язык, имеющий расширения, позволяющие вам определять подклассы GObject, их свойства, сигналы, реализации интерфейса и остальные функции GObject. Цель состоит в том, чтобы не требовать небезопасного кода с вашей стороны.

Это выглядит так:


gobject_gen! {    class MyClass: GObject {        foo: Cell<i32>,        bar: RefCell<String>,    }    impl MyClass {        virtual fn my_virtual_method(&self, x: i32) {            ... do something with x ...        }    }}

В "позиции элемента" это некий жаргон, но в основном это означает, что вы можете вызывать только gobject_gen! в определённых местах в вашего кода.


Rust 1.45.0 добавляет возможность вызывать процедурные макросы в трёх новых местах:


// представим, что мы имеем процедурный макрос "mac"mac!(); // позиция элемента, то, что было стабилизировано ранее// но здесь представлены 3 новых:fn main() {  let expr = mac!(); // в выражении  match expr {      mac!() => {} // в шаблоне  }  mac!(); // в стейтменте}

Возможность использовать макросы в большем количестве мест интересна, но есть ещё одна причина, по которой многие разработчики давно ждали эту функцию: Rocket. Популярный веб-фреймворк Rocket, первоначально выпущенный в декабре 2016 года, часто называют одной из лучших вещей, которую может предложить экосистема Rust. Вот пример "Привет, мир" из его предстоящего релиза:


#[macro_use] extern crate rocket;#[get("/<name>/<age>")]fn hello(name: String, age: u8) -> String {    format!("Hello, {} year old named {}!", age, name)}#[launch]fn rocket() -> rocket::Rocket {    rocket::ignite().mount("/hello", routes![hello])}

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


Следующая версия Rocket всё ещё находится в разработке, но когда она выйдет, многие будут очень довольны :)


Изменения в стандартной библиотеке


В Rust 1.45.0 были стабилизированы следующие функции:



Также теперь можно использовать char с диапазонами для итерации по символам:


for ch in 'a'..='z' {    print!("{}", ch);}println!();// Выведет "abcdefghijklmnopqrstuvwxyz"

Полный список изменений вы можете увидеть в детальных примечаниях к выпуску.


Другие изменения


Синтаксис, пакетный менеджер Cargo и анализатор Clippy также претерпели некоторые изменения.


Участники 1.45.0


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


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


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


Данную статью совместными усилиями перевели nlinker, funkill, Hirrolot и blandger.

Подробнее..

Перевод Закладывая фундамент будущего Rust

19.08.2020 18:13:30 | Автор: admin

Rust был задуман в 2010 (в зависимости от того, как вы считаете, можно сказать, что в 2006!) как проект в Mozilla Research, но его долгосрочной целью было создание самостоятельного проекта. В 2015, вместе с выпуском Rust 1.0, появилось управление, независимое от Mozilla. С тех пор Rust работает как автономная организация, а Mozilla выступает в качестве известного и постоянного финансового и юридического спонсора.


Mozilla была и продолжает восторгаться от возможности широкого использования и поддержки языка Rust многими компаниями в отрасли. Сегодня многие компании, как крупные так и малые, используют Rust более разнообразными и значительными способами: от Amazons Firecracker до Fastlys Lucet, в критических службах, которые "снабжают энергией" Discord, Cloudflare, Figma, 1Password и многие, многие другие.


Во вторник, 11 августа 2020 года, Mozilla объявила о реструктуризации компании и увольнении около 250 сотрудников, включая активных участников Rust и Rust сообщества. Понятно, что эти увольнения породили множество путаницы и неуверенности в отношении Rust. Цель этого поста решить эти проблемы. Также у нас есть важное объявление, о котором сказано дальше!


Влияние на сообщество


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


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


Наконец, мы хотели бы подчеркнуть, что в командах Rust участвуют разные люди и их участие не связано с работодателем. Сотрудники Mozilla, которые также являются членами команд Rust, продолжают оставаться членами команды сегодня, даже если они попали под увольнение. Конечно, кто-то может отказаться от своего участия. Мы понимаем, что не все могут продолжать вносить свой вклад и полностью поддерживаем их решение. Мы благодарны за все, что они сделали для проекта.


Создание фонда


По мере роста проекта, становления зрелым и популярным, мы начали чувствовать боль от нашего успеха. У нас появились правовые и финансовые нужды, которые наша текущая организация не в состоянии полностью удовлетворить. Пока мы достигаем этого при поддержке Mozilla, но мы достигли той точки, когда трудно работать без юридического имени, адреса и банковского счёта. Настало время, когда мы больше не можем откладывать вопрос "Как проект Rust подписывает контракты?".


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


Основываясь на этой работе, Mozilla и Rust Core Team рады сообщить о создании фонда Rust. Наша цель к концу года завершить первую итерацию создания фонда.


Первой задачей фонда будет то, в чём Rust уже хорош: получении владения (ownership). Но на этот раз реальный ресурс, а не что-то в программе. Различные торговые марки и доменные имена, ассоциированные с Rust, Cargo и crates.io перейдут фонду, который также возьмёт на себя финансовые расходы на их поддержку. Мы рассматриваем эту итерацию только как начало. Существует множество точек роста роли фонда и мы будем рады изучить их а будущем.


А пока мы сфокусированы на этих целях фонда. В качестве промежуточного шага Core Team выберет членов для создания группы, прилагающей усилия для создания фонда. Ожидайте увидеть следующие посты от данной группы с большим количеством деталей об этом процессе и возможностью обратной связи. А пока что вы можете написать группе по адресу foundation@rust-lang.org.


Развитие инфраструктуры


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


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


Спасибо


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


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


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


Данную статью совместными усилиями перевели andreevlex, Belanchuk, funkill, blandger и Hirrolot.

Подробнее..

Перевод Rust 1.46.0 track_caller и улучшения const fn

28.08.2020 22:20:21 | Автор: admin

Команда Rust рада объявить о новой версии Rust 1.46.0. Rust это язык программирования, который позволяет каждому создавать надёжное и эффективное программное обеспечение.


Если у вас установлена предыдущая версия Rust через rustup, получить Rust 1.46.0 так же просто, как:


rustup update stable

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


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


Этот выпуск достаточно небольшой, с улучшениями в const fn, стабилизацией двух новых API в стандартной библиотеке и одной опции, удобной для авторов библиотек. Смотрите подробные примечания к выпуску чтобы узнать о других изменениях, не представленных в данном анонсе.


#[track_caller]


Вернёмся в март, когда был выпущен Rust 1.42, в котором улучшились сообщения об ошибках, когда unwrap и подобные функции приводили к панике. Тогда мы упоминали, что реализация ещё не стабильна. В Rust 1.46 мы её стабилизировали.
Этот атрибут зовётся #[track_caller] и был предложен в RFC 2091 аж в июле 2017! Если вы пишете функцию, подобную unwrap, которая может приводить к панике, вы можете добавить эту аннотацию к вашей функции, и модуль форматирования паники по умолчанию будет использовать её для отображения сообщения об ошибке. Например, unwrap:


pub fn unwrap(self) -> T {    match self {        Some(val) => val,        None => panic!("вызван `Option::unwrap()` на значении `None`"),    }}

Теперь будет выглядеть так:


#[track_caller]pub fn unwrap(self) -> T {    match self {        Some(val) => val,        None => panic!("вызван `Option::unwrap()` на значении `None`"),    }}

Вот и всё!


Если вы сами реализуете ловушку паники, вы можете использовать метод вызывающей стороны в std::panic::Location, чтобы получить доступ к этой информации.


Улучшения const fn


Теперь вы также можете использовать в const fn некоторые базовые языковые вещи, такие как:


  • if, if let и match
  • while, while let и loop
  • операторы && и ||

А также преобразование в срез:


const fn foo() {  let x = [1, 2, 3, 4, 5];  // преобразовываем массив в срез  let y: &[_] = &x;}

Хотя эти функции могут не казаться вам новыми, учитывая, что вы можете использовать их все помимо const fn, они добавляют много вычислительной мощности во время компиляции! Как
например, библиотека const-sha1 может позволить вам вычислить хэши SHA1 во время компиляции. Это привело к 40-кратному повышению производительности в Microsoft WinRT для Rust.


Изменения в библиотеке


На волне улучшений в const fn, std::mem::forget теперь тоже const fn. Дополнительно в этом выпуске были стабилизированы два новых API:



Для получения более детальной информации, смотрите подробные примечания к выпуску.


Другие изменения


Синтаксис, пакетный менеджер Cargo и анализатор Clippy также претерпели некоторые изменения.


Участники 1.46.0


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


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


С любыми вопросами по языку Rust вам смогут помочь в русскоязычном Телеграм-чате или же в аналогичном чате для новичковых вопросов. Если у вас есть вопросы по переводам или хотите помогать с ними, то обращайтесь в чат переводчиков.
Так же можете поддержать нас на opencollective: https://opencollective.com/rust-lang-ru.


Данную статью совместными усилиями перевели funkill, Hirrolot и andreevlex.

Подробнее..

Перевод Rust 1.47.0 const generics для массивов, LLVM 11, Control Flow Guard и сокращение трассировок

09.10.2020 12:10:51 | Автор: admin

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


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


rustup update stable

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


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


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


Типажи на больших массивах


Rust всё ещё не поддерживает обобщения для целочисленных значений. Это давно вызывает проблемы с массивами, так как они имеют целочисленную часть в своём типе. [T; N] представляет массив длины N со значениями типа T. Поскольку нет способа сделать его обобщённым по N, типажи для массивов приходится реализовывать вручную для каждого нужного вам N. Для стандартной библиотеки было решено поддерживать N до 32.


Мы работали над особенностью, называемой "const generics" ("константные обобщения"), которая позволяет вам обобщать по N. Полное описание константных обобщений выходит за рамки данного анонса, так как они ещё до конца не стабилизированы. Однако, основная их часть реализована в компиляторе и было принято решение, что константные обобщения достаточно готовы, чтобы использовать их в стандартной библиотеке для массивов любой длины. На практике это означает, что если вы попытаетесь сделать нечто подобное в Rust 1.46:


fn main() {    let xs = [0; 34];    println!("{:?}", xs);}

то получите такую ошибку:


error[E0277]: arrays only have std trait implementations for lengths 0..=32 --> src/main.rs:4:22  |4 |     println!("{:?}", xs);  |                      ^^ the trait `std::array::LengthAtMost32` is not implemented for `[{integer}; 34]`  |  = note: required because of the requirements on the impl of `std::fmt::Debug` for `[{integer}; 34]`  = note: required by `std::fmt::Debug::fmt`  = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

Но в Rust 1.47 массив распечатается правильно.


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


Более короткие трассировки


Вернёмся в Rust 1.18, где мы внесли некоторые изменения в трассировки, которые rustc добавлял при панике. В них есть несколько вещей, которые большую часть времени бесполезны. Однако, в некоторых случаях они регрессировали. В Rust 1.47 виновник нашёлся и был исправлен. С момента регресса эта программа:


fn main() {    panic!();}

давала подобную трассировку:


thread 'main' panicked at 'explicit panic', src/main.rs:2:5stack backtrace:   0: backtrace::backtrace::libunwind::trace             at /cargo/registry/src/github.com-1ecc6299db9ec823/backtrace-0.3.46/src/backtrace/libunwind.rs:86   1: backtrace::backtrace::trace_unsynchronized             at /cargo/registry/src/github.com-1ecc6299db9ec823/backtrace-0.3.46/src/backtrace/mod.rs:66   2: std::sys_common::backtrace::_print_fmt             at src/libstd/sys_common/backtrace.rs:78   3: <std::sys_common::backtrace::_print::DisplayBacktrace as core::fmt::Display>::fmt             at src/libstd/sys_common/backtrace.rs:59   4: core::fmt::write             at src/libcore/fmt/mod.rs:1076   5: std::io::Write::write_fmt             at src/libstd/io/mod.rs:1537   6: std::sys_common::backtrace::_print             at src/libstd/sys_common/backtrace.rs:62   7: std::sys_common::backtrace::print             at src/libstd/sys_common/backtrace.rs:49   8: std::panicking::default_hook::{{closure}}             at src/libstd/panicking.rs:198   9: std::panicking::default_hook             at src/libstd/panicking.rs:217  10: std::panicking::rust_panic_with_hook             at src/libstd/panicking.rs:526  11: std::panicking::begin_panic             at /rustc/04488afe34512aa4c33566eb16d8c912a3ae04f9/src/libstd/panicking.rs:456  12: playground::main             at src/main.rs:2  13: std::rt::lang_start::{{closure}}             at /rustc/04488afe34512aa4c33566eb16d8c912a3ae04f9/src/libstd/rt.rs:67  14: std::rt::lang_start_internal::{{closure}}             at src/libstd/rt.rs:52  15: std::panicking::try::do_call             at src/libstd/panicking.rs:348  16: std::panicking::try             at src/libstd/panicking.rs:325  17: std::panic::catch_unwind             at src/libstd/panic.rs:394  18: std::rt::lang_start_internal             at src/libstd/rt.rs:51  19: std::rt::lang_start             at /rustc/04488afe34512aa4c33566eb16d8c912a3ae04f9/src/libstd/rt.rs:67  20: main  21: __libc_start_main  22: _start

Теперь, с Rust 1.47.0, вместо неё вы увидите следующее:


thread 'main' panicked at 'explicit panic', src/main.rs:2:5stack backtrace:   0: std::panicking::begin_panic             at /rustc/d6646f64790018719caebeafd352a92adfa1d75a/library/std/src/panicking.rs:497   1: playground::main             at ./src/main.rs:2   2: core::ops::function::FnOnce::call_once             at /rustc/d6646f64790018719caebeafd352a92adfa1d75a/library/core/src/ops/function.rs:227

Это позволяет намного легче увидеть, где произошла паника, но вы всё также можете установить RUST_BACKTRACE=full, если хотите видеть всё.


LLVM 11


Мы обновились до LLVM 11. Компилятор по-прежнему может собираться с версиями LLVM до 8, но по умолчанию использует 11 версию.


Control Flow Guard на Windows


rustc теперь поддерживает -C control-flow-guard, опцию, которая включает Control Flow Guard на Windows. Для других платформ этот флаг игнорируется.


Изменения в стандартной библиотеке


Дополнительно в этом выпуске были стабилизированы девять новых API:



Следующие, ранее стабилизированные API, стали const:



Для получения более детальной информации, смотрите подробные примечания к выпуску.


Другие изменения


Rustdoc начал поддерживать тему Ayu.


Синтаксис, пакетный менеджер Cargo и анализатор Clippy также претерпели некоторые изменения.


Участники 1.47.0


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


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


С любыми вопросами по языку Rust вам смогут помочь в русскоязычном Телеграм-чате или же в аналогичном чате для новичковых вопросов. Если у вас есть вопросы по переводам или хотите помогать с ними, то обращайтесь в чат переводчиков.
Так же можете поддержать нас на opencollective: https://opencollective.com/rust-lang-ru.


Данную статью совместными усилиями перевели ArtemZdor, fan-tom, funkill, blandger и andreevlex.

Подробнее..

Перевод Rust 1.49.0 aarch64 и улучшения во фреймворке тестирования

02.01.2021 16:06:38 | Автор: admin

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


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


rustup update stable

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


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


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


64-bit ARM Linux перешёл в Tier 1


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


  • Tier 3 технически, платформы поддерживаются компилятором, но мы не проверяли собирается ли на них код или проходят ли тесты, и мы не предоставляем каких-либо бинарных артефактов, как часть наших релизов.
  • Платформы из Tier 2 гарантированно собираются, но мы не запускаем для них тесты: предоставляемые артефакты могут быть не рабочими или быть с багами.
  • Для платформ из Tier 1 предоставляются наибольшие гарантии и мы запускаем все тесты для этих платформ для каждого изменения, влитого в компилятор. Также мы предоставляем для них собранные артефакты.

Начиная с Rust 1.49.0 платформа aarch64-unknown-linux-gnu передвигается на уровень поддержки Tier 1, предоставляя наши наибольшие гарантии для пользователей Linux, запущенных на 64-bit ARM системах! Мы ожидаем, что данное изменение принесёт пользу для всех: от встраиваемых систем до обычных компьютеров и серверов.


Это важный этап для нашего проекта, поскольку это первая не-x86 платформа, получившая Tier 1 поддержку: мы надеемся, этот шаг откроет путь для большего количества платформ, которые смогу достичь нашего высшего уровня поддержки.


Обратим внимание, что Android не затрагивается данным изменением, так как он представлен другой платформой, находящейся в Tier 2.


64-bit ARM macOS и Windows переходят в Tier 2


В Rust 1.49.0 ещё две платформы достигли Tier 2:


  • Платформа aarch64-apple-darwin предоставляет поддержку Rust на системах Apple M1.
  • aarch64-pc-windows-msvc предоставляет поддержку Rust на 64-bit ARM устройствах, работающих под Windows.

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


Фреймворк для тестирования захватывает вывод из потоков


Встроенный в Rust фреймворк для тестирования довольно минималистичен, но это не значит, что его нельзя улучшить! Представьте, что тест выглядит примерно так:


#[test]fn thready_pass() {    println!("fee");    std::thread::spawn(|| {        println!("fie");        println!("foe");    })    .join()    .unwrap();    println!("fum");}

Вот как выглядел запуск этого теста до Rust 1.49.0:


 cargo +1.48.0 test   Compiling threadtest v0.1.0 (C:\threadtest)    Finished test [unoptimized + debuginfo] target(s) in 0.38s     Running target\debug\deps\threadtest-02f42ffd9836cae5.exerunning 1 testfiefoetest thready_pass ... oktest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out   Doc-tests threadtestrunning 0 teststest result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

Вы можете заметить, что вывод из потоков напечатался и смешался с выводом самого фреймворка. Было бы неплохо, если бы каждый println! работал также, как тот, что напечатал "fum"? Что ж, таково поведение в Rust 1.49.0:


 cargo test   Compiling threadtest v0.1.0 (C:\threadtest)    Finished test [unoptimized + debuginfo] target(s) in 0.52s     Running target\debug\deps\threadtest-40aabfaa345584be.exerunning 1 testtest thready_pass ... oktest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s   Doc-tests threadtestrunning 0 teststest result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

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


 cargo test   Compiling threadtest v0.1.0 (C:\threadtest)    Finished test [unoptimized + debuginfo] target(s) in 0.52s     Running target\debug\deps\threadtest-40aabfaa345584be.exerunning 1 testtest thready_pass ... FAILEDfailures:---- thready_pass stdout ----feefiefoefumthread 'thready_pass' panicked at 'explicit panic', src\lib.rs:11:5

В частности, средство запуска тестов обеспечивает захват вывода и сохраняет его в случае сбоя теста.


Изменения в стандартной библиотеке


В Rust 1.49.0 были стабилизированы следующие 3 функции:



И ещё две функции стали const:



Смотрите подробные примечания к выпуску для более детальной информации.


Другие изменения


Синтаксис, пакетный менеджер Cargo и анализатор Clippy также претерпели некоторые изменения.


Участники 1.49.0


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


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


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


Данную статью совместными усилиями перевели andreevlex, funkill, ozkriff, blandger и fan-tom.

Подробнее..

Перевод Rust 1.50.0 улучшение индексации массивов, безопасность полей объединений и усовершенствование файловых дескрипторов

12.02.2021 12:08:58 | Автор: admin

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


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


rustup update stable

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


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


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


Константные обобщения при индексации массива


Продолжая движение к стабилизации константных обобщений, этот выпуск добавляет реализации ops::Index и IndexMut для массивов [T; N] любой длины const N. Оператор индексации [] уже работал с массивами с помощью встроенной магии компилятора, но на уровне типа массивы до сих пор фактически не реализовывали библиотечные типажи.


fn second<C>(container: &C) -> &C::Outputwhere    C: std::ops::Index<usize> + ?Sized,{    &container[1]}fn main() {    let array: [i32; 3] = [1, 2, 3];    assert_eq!(second(&array[..]), &2); // срезы работали ранее    assert_eq!(second(&array), &2); // теперь это работает напрямую}

const повторение значений массива


Массивы в Rust могут быть записаны как в форме списков [a, b, c], так и в форме повторений [x; N]. Повторения разрешены для длины N большей, чем один, только для x, реализующих типаж Copy, и в рамках RFC 2203 мы стремились разрешить любые const выражения. Однако пока эта функциональность была нестабильна для произвольных выражений, лишь начиная с Rust 1.38 её реализация случайно позволила использовать const значения в повторениях массивов.


fn main() {    // Это не разрешено, так как `Option<Vec<i32>>` не реализует `Copy`.    let array: [Option<Vec<i32>>; 10] = [None; 10];    const NONE: Option<Vec<i32>> = None;    const EMPTY: Option<Vec<i32>> = Some(Vec::new());    // Однако повторения с `const` значениями разрешены!    let nones = [NONE; 10];    let empties = [EMPTY; 10];}

В Rust 1.50 эта возможность признана официально, так что вы можете использовать такие конструкции без опасений. В будущем для того, чтобы избежать "временных" именований констант, вы можете использовать встроенные выражения const согласно RFC 2920.


Безопасные присвоения полям объединения ManuallyDrop<T>


В Rust 1.49 появилась возможность добавлять поля ManuallyDrop<T> в union, позволяющая таким образом использовать Drop для объединений. Однако объединения не сбрасывают старые значения во время присваивания полей, так как не знают, какой из вариантов ранее был действителен. Поэтому из соображений безопасности Rust ранее ограничивался только типами Copy, которые не используют Drop. Разумеется, ManuallyDrop<T> не требует Drop, поэтому теперь Rust 1.50 расценивает присваивания и этим полям как безопасные.


Ниша для File на Unix платформах


У некоторых типов в Rust есть определённые ограничения на то, какое значение считать допустимым, поскольку они могут выходить за границы допустимых значений диапазона памяти. Мы называем любое оставшееся недопустимое значение нишей (niche), и это пространство может быть использовано для оптимизации схемы размещения типов. Например, в Rust 1.28 мы представили целочисленные типы NonZero, такие как NonZeroU8, где 0 ниша. Это позволило Option<NonZero> использовать 0, чтобы представить None без использования дополнительной памяти.


На Unix-платформах File это просто системный целочисленный файловый дескриптор. Это значит, что у нас есть возможная ниша ведь он никогда не может быть -1! Системные вызовы, которые возвращают файловый дескриптор, используют -1 для обозначения того, что произошла ошибка (проверяется errno), так что -1 никогда не будет действительным файловым дескриптором. Начиная с Rust 1.50 эта ниша добавлена в определение типа и тоже может быть использована для оптимизации размещения значения в памяти. И следовательно Option<File> теперь имеет такой же размер, как и File!


Изменения в стандартной библиотеке


В Rust 1.50.0 были стабилизированы следующие 9 функций:



И довольно много существующих функций стало const:


  • IpAddr::is_ipv4
  • IpAddr::is_ipv6
  • Layout::size
  • Layout::align
  • Layout::from_size_align
  • pow для всех целочисленных типов
  • checked_pow для всех целочисленных типов
  • saturating_pow для всех целочисленных типов
  • wrapping_pow для всех целочисленных типов
  • next_power_of_two для всех беззнаковых целочисленных типов
  • checked_power_of_two для всех беззнаковых целочисленных типов

Смотрите подробные примечания к выпуску для более детальной информации.


Другие изменения


Синтаксис, пакетный менеджер Cargo и анализатор Clippy также претерпели некоторые изменения.


Участники 1.50.0


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


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


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


Данную статью совместными усилиями перевели andreevlex, TelegaOvoshey, blandger, nlinker и funkill.

Подробнее..

Перевод Планирование редакции Rust 2021

05.03.2021 22:04:25 | Автор: admin

Рабочая группа Rust 2021 Edition рада сообщить, что следующая редакция Rust Rust 2021 запланирована на этот год. Пока что формально описывающий её RFC остаётся открытым, но мы ожидаем, что в скором времени он будет принят. Планирование и подготовка уже начались, и мы идём по графику!


Если вам интересно, какие новшества появятся в Rust 2021 или когда эта редакция выйдет в стабильной версии, читайте нашу статью!


Что входит в эту редакцию?


Конечный список нововведений, которые войдут в Rust 2021, ещё не определён до конца. В целом мы планируем, что выпуск Rust 2021 будет намного меньше, чем Rust 2018, по следующим причинам:


  • Ритм выпусков стал регулярным Это значит, что мы будем активно использовать плюсы "цепочечной" модели на уровне редакций Rust.
  • Редакция Rust 2018 выбилась из модели "минимального стресса" выпусков.
  • Сейчас просто нужно меньше фундаментальных изменений, чтобы язык продолжал развиваться.

Более подробно о развитии концепции редакций вы можете почитать в RFC.


Решение, войдёт ли та или иная функциональность в Rust 2021, является частью процесса RFC поэтому список ожидаемых функций может и будет меняться. Это будет происходить до самого момента выпуска, но тем не менее, уже сейчас мы можем рассмотреть список функций, которые, скорее всего, в неё войдут.


Изменения в прелюдии


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


Сейчас в редакцию Rust 2021 предложено включить следующие трейты:


  • TryFrom/TryInto
  • FromIterator

RFC с этими изменениями можно найти тут. Обратите внимание, что RFC ещё не принят состав новой прелюдии активно обсуждается.


Новые правила захвата


RFC 2229 предлагает, когда это возможно, захватывать замыканиями отдельные поля, а не всю структуру целиком. Этот RFC уже принят. В некоторых случаях такое изменение может заставить деструкторы запускаться в другом месте, нежели сейчас, из-за чего оно должно быть привязано к редакции. Миграция анализаторов должна свести к минимум изменения в семантике уже существующего кода.


Новый распознаватель функциональности в Cargo по умолчанию


В Rust 1.51 будет стабилизирован новый распознаватель функциональности в Cargo, который разрешит зависимостям пакета использовать разную функциональность в разных контекстах. Например, пакет с #[no_std] сможет использовать одну и ту же зависимость и во время сборки (build-dependencies с включённым std), и как обычную зависимость (без std). Пока что это приводит к тому, что std будет включена в обоих случаях, так как функциональность находится в глобальном пространстве имён.


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


Прочие изменения


Другие предложенные изменения включают унификацию работы panic в std и core и обновление уровня некоторых проверок с предупреждений до ошибок.


Полный список обсуждаемых функций вы можете найти здесь.


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


Примерный график


Итак, когда же мы планируем выпустить новую редакцию? Вот график основных этапов, к которому мы стремимся:


  • 1 апреля все релевантные редакции RFC или приняты, или в хорошем состоянии (т. е. все основные вопросы решены, и принятие RFC произойдёт в ближайшие недели).
  • 1 мая все нововведения, включённые в Rust 2021, находятся в Nightly с соответствующими feature-флагами.
  • 1 июня все проверки добавлены в Nightly.
  • 1 сентября редакция стабилизирована в Nightly.
  • 21 октября редакция полностью стабилизирована.

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


Приглашаем к участию


Если вы хотите помочь в выпуске редакции Rust 2021 пожалуйста, свяжитесь с нами. Помимо работы над функциональностью и планированием выпуска, у будет ещё очень много других важных дел. Вот только часть того, что необходимо для успешного выпуска:


  • rustfix миграции для всех соответствующих функций,
  • тестирование всех функций и путей их миграции,
  • сообщения в блогах и другие маркетинговые материалы.

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


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


Данную статью совместными усилиями перевели blandger, TelegaOvoshey, funkill и andreevlex.

Подробнее..

Перевод Rust 1.51.0 const generics MVP, новый распознаватель функциональности Cargo

26.03.2021 20:17:43 | Автор: admin

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


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


rustup update stable

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


Что было стабилизировано в 1.51.0


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


Константные обобщения (Const Generics MVP)


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


struct FixedArray<T> {              // ^^^ Определение обобщённого типа.    list: [T; 32]        // ^ Где мы использовали его.}

Если затем мы используем FixedArray<u8>, компилятор создаст мономорфизированную версию FixedArray, которая выглядит так:


struct FixedArray<u8> {    list: [u8; 32]}

Этот полезный функционал позволяет писать повторно используемый код без дополнительных затрат во время выполнения. Однако до этого выпуска у нас не было возможности легко объединять значения таких типов. Это наиболее заметно в массивах, где длина указывается в определении типа ([T; N]). Теперь в версии 1.51.0 вы можете писать код, который будет обобщённым для значений любого числа, типа bool или char! (Использование значений struct и enum по-прежнему не стабилизировано.)


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


struct Array<T, const LENGTH: usize> {    //          ^^^^^^^^^^^^^^^^^^^ Определение константного обобщения.    list: [T; LENGTH]    //        ^^^^^^ Мы использовали его здесь.}

Теперь если мы используем Array<u8, 32>, компилятор создаст мономорфизированную версию Array, которая выглядит так:


struct Array<u8, 32> {    list: [u8; 32]}

Константные обобщения добавляют важный новый инструмент для разработчиков библиотек, чтобы создавать новые, мощные и безопасных API во время компиляции. Если вы хотите узнать больше о константных обобщениях, можете почитать статью в блоге Const Generics MVP Hits Beta для получения дополнительной информации об этой функции и её текущих ограничениях. Нам не терпится увидеть, какие новые библиотеки и API вы создадите!


Стабилизация array::IntoIter


Как часть стабилизации константных обобщений, мы также стабилизировали использующее их новое API std::array::IntoIter. IntoIter позволяет вам создать поверх массива итератор по значению. Ранее не было удобного способа итерироваться по самим значениям, только по ссылкам.


fn main() {  let array = [1, 2, 3, 4, 5];  // Раньше  for item in array.iter().copied() {      println!("{}", item);  }  // Теперь  for item in std::array::IntoIter::new(array) {      println!("{}", item);  }}

Обратите внимание, что это было добавлено вместо .into_iter() как отдельный метод, так как сейчас оно ломает текущее соглашение о том, что .into_iter() относится к срезам по ссылочному итератору. Мы изучаем возможности в будущем сделать такой код более эргономичным.


Новый распознаватель функциональности Cargo


Управление зависимостями сложная задача, и одна из самых сложных её частей выбор версии зависимости, когда от неё зависят два разных пакета. Здесь учитывается не только номер версии, но и то, какая функциональность была включена или выключена для пакета. По умолчанию Cargo объединяет функциональные флаги (features) для одного пакета, если он встречается в графе зависимостей несколько раз.


Например, у вас есть зависимость foo с функциональными флагами A и B, которые используются пакетами bar and baz, но bar зависит от foo+A, а baz от foo+B. Cargo объединит оба флага и соберёт foo как foo+AB. Выгода здесь в том, что foo будет собран только один раз и далее будет использован и для bar, и для baz.


Но у этого решения есть и обратная сторона. Что, если функциональный флаг подключён как build-зависимость, но не совместим с конечной целью сборки?


Общим примером этого из экосистемы может служить опциональная функциональность std во многих #![no_std] пакетах, которая позволяет этим пакетам предоставить дополнительную функциональность, если она включена. Теперь представим, что вы хотите использовать #![no_std] версию foo в вашей #![no_std] программе и использовать foo во время сборки в build.rs. Так как во время сборки вы зависите от foo+std, то и ваша программа тоже зависит от foo+std, а значит более не может быть скомпилирована, так как std не доступна для вашей целевой платформы.


Это была давняя проблема в Cargo, и с этим выпуском появилась новая опция resolver в вашем Cargo.toml, где вы можете установить resolver="2", чтобы попробовать новый подход к разрешению функциональных флагов. Вы можете ознакомиться с RFC 2957 для получения подробного описания поведения, которое можно резюмировать следующим образом.


  • Dev dependencies когда пакет используется совместно как обычная зависимость и dev, возможности dev-зависимости включаются только в том случае, если текущая сборка включает dev-зависимости.
  • Host Dependencies когда пакет совместно используется как обычная зависимость и зависимость сборки или процедурный макрос, features для нормальной зависимости сохраняются независимо от зависимости сборки или процедурного макроса.
  • Target dependencies когда у пакета включены зависимые от платформы features, и он присутствует в графе сборки несколько раз, будут включены только features, подходящие текущей платформе сборки.

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


[package]resolver = "2"# Или если вы используете workspace[workspace]resolver = "2"

Разделение отладочной информации


Хоть это и нечасто освещается в релизах, команда Rust постоянно работает над сокращением времени компиляции. В этом выпуске вносится самое крупное улучшение за долгое время для Rust на macOS. Отладочная информация исходного кода содержится в собранном бинарнике, и за счет этого программа может дать больше информации о том, что происходит во время исполнения. Раньше в macOS отладочная информация собиралась в единую директорию .dSYM при помощи утилиты dsymutil, что могло занимать много времени и дискового пространства.


Сбор всей отладочной информации в эту директорию помогал найти её во время выполнения, особенно если бинарник перемещался. Однако у такого решения есть и обратная сторона: если вы сделали небольшое изменение в вашей программе, то dsymutil необходимо запустить над всем собранным бинарником, чтобы собрать директорию .dSYM. Иногда это могло сильно увеличить время сборки, особенно для крупных проектов, поскольку надо перебирать все зависимости, но это важный шаг, без которого стандартная библиотека Rust не знает, как загружать отладочную информацию на macOS.


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


Вы можете включить новое поведение, установив флаг -Csplit-debuginfo=unpacked при запуске rustc или задав опцию split-debuginfo в unpacked раздела [profile] в Cargo. С опцией "unpacked" rustc будет оставлять объектные файлы (.o) в директории сборки вместо их удаления и пропустит запуск dsymutil. Поддержка бэктрейсов Rust достаточно умна, чтобы понять, как найти эти .o файлы. Такие инструменты, как lldb, также знают, как это делается. Это должно работать до тех пор, пока вам не понадобится переместить бинарники в другое место и сохранить отладочную информацию.


[profile.dev]split-debuginfo = "unpacked"

Стабилизированные API


Итого: в этом выпуске было стабилизировано 18 новых методов для разных типов, например slice и Peekable. Одним из примечательных дополнений является стабилизация ptr::addr_of! и ptr::addr_of_mut!, которая позволяет вам создавать сырые указатели для полей без выравнивания. Ранее это было невозможно, так как Rust требовал, чтобы &/&mut были выровнены и указывали на инициализированные данные. Из-за этого преобразование &addr as *const _ приводило к неопределённому поведению, так как &addr должно быть выровнено. Теперь эти два макроса позволяют вам безопасно создать невыровненные указатели.


use std::ptr;#[repr(packed)]struct Packed {    f1: u8,    f2: u16,}let packed = Packed { f1: 1, f2: 2 };// `&packed.f2` будет создана ссылка на невыровненную память, таким образом это неопределённое поведение!let raw_f2 = ptr::addr_of!(packed.f2);assert_eq!(unsafe { raw_f2.read_unaligned() }, 2);

Следующие методы были стабилизированы:



Другие изменения


Синтаксис, пакетный менеджер Cargo и анализатор Clippy также претерпели некоторые изменения.


Участники 1.51.0


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


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


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


Данную статью совместными усилиями перевели andreevlex, TelegaOvoshey, blandger, nlinker и funkill.

Подробнее..

Перевод Rust 1.52.0 улучшения Clippy и стабилизация API

07.05.2021 14:19:42 | Автор: admin

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


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


rustup update stable

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


Что было стабилизировано в 1.52.0


Самое значительное изменение этого выпуска не касается самого языка или стандартной библиотеки. Это улучшения в Clippy.


Ранее запуск cargo clippy после cargo check не запускал Clippy: кэширование в Cargo не видело разницы между ними. В версии 1.52 это поведение было исправлено, а значит, теперь пользователи будут получать то поведение, которое ожидают, независимо от порядка запуска этих команд.


Стабилизированные API


Следующие методы были стабилизированы:



Следующие ранее стабилизированные API стали const:



Другие изменения


Синтаксис, пакетный менеджер Cargo и анализатор Clippy также претерпели некоторые изменения.


Участники 1.52.0


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


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


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


Данную статью совместными усилиями перевели Belanchuk, TelegaOvoshey, blandger, nlinker и funkill.

Подробнее..

Перевод Rust 1.53.0 IntoIterator для массивов, quotquot в шаблонах, Unicode-идентификаторы, поддержка имени HEAD-ветки в Cargo

18.06.2021 18:20:53 | Автор: admin

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


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


rustup update stable

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


Что было стабилизировано в 1.53.0


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


IntoIterator для массивов


Это первый выпуск Rust, в котором массивы реализуют типаж IntoIterator. Теперь вы можете итерироваться в массиве по значению:


for i in [1, 2, 3] {    ..}

Раньше это было возможно только по ссылке, с помощью &[1, 2, 3] или [1, 2, 3].iter().


Аналогично вы теперь можете передать массив в методы, ожидающие T: IntoIterator:


let set = BTreeSet::from_iter([1, 2, 3]);

for (a, b) in some_iterator.chain([1]).zip([1, 2, 3]) {    ..}

Это не было реализовано ранее из-за проблем с совместимостью. IntoIterator всегда реализуется для ссылок на массивы и в предыдущих выпусках array.into_iter() компилировался, преобразовываясь в (&array).into_iter().


Начиная с этого выпуска, массивы реализуют IntoIterator с небольшими оговорками для устранения несовместимости кода. Компилятор, как и прежде, преобразовывает array.into_iter() в (&array).into_iter(), как если бы реализации типажа ещё не было. Это касается только синтаксиса вызова метода .into_iter() и не затрагивает, например, for e in [1, 2, 3], iter.zip([1, 2, 3]) или IntoIterator::into_iter([1, 2, 3]), которые прекрасно компилируются.


Так как особый случай .into_iter() необходим только для предотвращения поломки существующего кода, он будет удалён в новой редакции Rust 2021, которая выйдет позже в этом году. Если хотите узнать больше следите за анонсами редакции.


"Или" в шаблонах


Синтаксис шаблонов был расширен поддержкой |, вложенного в шаблон где угодно. Это позволяет писать Some(1 | 2) вместо Some(1) | Some(2).


match result {     Ok(Some(1 | 2)) => { .. }     Err(MyError { kind: FileNotFound | PermissionDenied, .. }) => { .. }     _ => { .. }}

Unicode-идентификаторы


Теперь идентификаторы могут содержать не-ASCII символы. Можно использовать все действительные идентификаторы символов Unicode, определённые в UAX #31. Туда включены символы из многих разных языков и письменностей но не эмодзи.


Например:


const BLHAJ: &str = "";struct  {    : String,}let  = 1;

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


warning: identifier pair considered confusable between `` and `s`

Поддержка имени HEAD-ветки в Cargo


Cargo больше не предполагает, что HEAD-ветка в git-репозитории называется master. А следовательно, вам не надо указывать branch = "main" для зависимостей из git-репозиториев, в которых ветка по умолчанию main.


Инкрементальная компиляция до сих пор отключена по умолчанию


Как ранее говорилось в анонсе 1.52.1, инкрементальная компиляция была отключена для стабильных выпусков Rust. Функциональность остаётся доступной в каналах beta и nightly. Метод включения инкрементальной компиляции в 1.53.0 не изменился с 1.52.1.


Стабилизированные API


Следующие методы и реализации типажей были стабилизированы:



Другие изменения


Синтаксис, пакетный менеджер Cargo и анализатор Clippy также претерпели некоторые изменения.


Участники 1.53.0


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




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


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


Данную статью совместными усилиями перевели TelegaOvoshey, blandger, Belanchuk и funkill.

Подробнее..

Категории

Последние комментарии

  • Имя: Макс
    24.08.2022 | 11:28
    Я разраб в IT компании, работаю на арбитражную команду. Мы работаем с приламы и сайтами, при работе замечаются постоянные баны и лаги. Пацаны посоветовали сервис по анализу исходного кода,https://app Подробнее..
  • Имя: 9055410337
    20.08.2022 | 17:41
    поможем пишите в телеграм Подробнее..
  • Имя: sabbat
    17.08.2022 | 20:42
    Охренеть.. это просто шикарная статья, феноменально круто. Большое спасибо за разбор! Надеюсь как-нибудь с тобой связаться для обсуждений чего-либо) Подробнее..
  • Имя: Мария
    09.08.2022 | 14:44
    Добрый день. Если обладаете такой информацией, то подскажите, пожалуйста, где можно найти много-много материала по Yggdrasil и его уязвимостях для написания диплома? Благодарю. Подробнее..
© 2006-2024, personeltest.ru