LINUX.ORG.RU

Вышел Rust 1.20

 


2

7

Команда разработчиков Rust с удовольствием объявляет о выходе новой стабильной версии Rust: 1.20.0.

Rust — это язык программирования, ориентированный на безопасность, скорость и параллелизм.

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

rustup update stable

(Прим. пер. - иногда предварительно нужно выполнить rustup self update)

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

Что нового в стабильной версии Rust 1.20.0

В предыдущих версиях Rust вы уже могли определять «ассоциированные функции» для трейтов, структур и типов-сумм:

struct Struct;

impl Struct {
    fn foo() {
        println!("foo - это ассоциированная функция структуры Struct");
    }
}

fn main() {
    Struct::foo();
}

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

В Rust 1.20 добавлена возможность использовать «ассоциированные константы»:

struct Struct;

impl Struct {
    const ID: u32 = 0;
}

fn main() {
    println!("ID структуры Struct: {}", Struct::ID);
}
Здесь константа ID ассоциирована со структурой Struct. Как и функции, ассоциированные константы могут быть определены для трейтов и типов-сумм.

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

trait Trait {
    const ID: u32;
}

struct Struct;

impl Trait for Struct {
    const ID: u32 = 5;
}

fn main() {
    println!("{}", Struct::ID);
}
В предыдущих релизах Rust при реализации трейта, представляющего числа с плавающей точкой, приходилось писать такой код:
trait Float {
    fn nan() -> Self;
    fn infinity() -> Self;
    ...
}
Это немного неудобно, но, что более важно, такие функции невозможно использовать для определения констант. Из-за этого приходилось вводить дополнительные константы:
mod f32 {
    const NAN: f32 = 0.0f32 / 0.0f32;
    const INFINITY: f32 = 1.0f32 / 0.0f32;

    impl Float for f32 {
        fn nan() -> Self {
            f32::NAN
        }
        fn infinity() -> Self {
            f32::INFINITY
        }
    }
}
Ассоциированные константы позволяют реализовать всё это намного проще. Трейт будет выглядеть таким образом:
trait Float {
    const NAN: Self;
    const INFINITY: Self;
    ...
}
А его реализация станет намного проще и расшит возможности использования трейта:
mod f32 {
    impl Float for f32 {
        const NAN: f32 = 0.0f32 / 0.0f32;
        const INFINITY: f32 = 1.0f32 / 0.0f32;
    }
}
Ассоциированные константы были предложены три года назад в RFC 195. И мы наконец смогли их реализовать! Этот RFC содержал все виды ассоциированных элементов, не только константы. Некоторые из них мы смогли реализовать быстрее чем другие. Мы много работаем над улучшением поддержки работы с константными выражениями, чтобы увеличить возможности Rust в области мета-программирования во время компиляции. В будущем в этой области появятся дополнительные возможности.

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

Стабилизация библиотек

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

Макро unimplemented! теперь принимает параметр, в котором можно указать причину отсутствия реализации.

Добавлена поддержка Unicode 10.0.0.

Функции min и max были переписаны на Rust, и больше не используют cmath.

Внедрена защита от уязвимости Stack Clash. Основные изменения: stack probes и отключение дополнительных ручных проверок для стека основного потока. Для включения защиты достаточно скомпилировать проект в Rust 1.20, изменения в коде не требуются.

В стандартную библиотеку добавлены три новые функции сортировки: slice::sort_unstable_by_key, slice::sort_unstable_by и slice::sort_unstable. Как вы заметили, все три содержат «unstable» в названиях. Стабильность — это свойство алгоритма сортировки, которое требуется не всегда, но раньше в стандартной библиотеке не было алгоритмов нестабильной сортировки. Теперь доступны обе возможности! Для демонстрации разницы между этими видами сортировки рассмотрим список:

rust
crate
package
cargo
Список, отсортированный алгоритмом стабильной сортировки только по первой букве, должен выглядеть таким образом:
crate
cargo
package
rust
То есть, если в исходном списке слово crate предшествовало слову cargo, то и в отсортированном списке оно должно стоять первым. Алгоритм нестабильной сортировки тоже может выдать такой результат, но допускается и вариант с измененной последовательностью:
cargo
crate
package
rust
Как вы понимаете, меньшее количество ограничений часто позволяет создать более быстрый алгоритм. Если вам не важна стабильность сортировки, нестабильная сортировка может оказаться быстрее, чем стабильный вариант. Как обычно, лучше попробовать оба варианта и сравнить их скорость. Эти функции сортировки были добавлены в RFC 1884. По ссылке вы можете узнать больше подробностей, включая результаты бенчмарков.

Также были стабилизированы следующие API:

и некоторые другие.

Возможности cargo

Этот релиз внес полезные улучшения в менеджер пакетов cargo. Первое и самое важное: токен аутентификации для crates.io хранился в ~/.cargo/config. Обычно маска доступа для файлов конфигурации устанавливается в 644, то есть чтение разрешено всем. Но в этом файле хранится секретный токен. Мы переместили токен в отдельный файл ~/.cargo/credentials, таким образом для него может быть установлен доступ 600, и он будет скрыт от других пользователей системы.

Если вы использовали пакеты Cargo, создающие дополнительные исполняемые файлы, вы знаете, что их исходный код хранится в src/bin. Но иногда вам может понадобиться создать несколько дополнительных исполняемых файлов, требующих много кода. В этом случае код может храниться в файлах src/bin/client.rs и src/bin/server.rs и все субмодули этих файлов попадут в один каталог, что неудобно и создает путаницу. Теперь мы используем соглашение, что такие файлы как src/bin/server/main.rs и src/bin/client/main.rs также используются для создания дополнительных исполняемых файлов. Это позволяет удобнее разграничить код.

>>> Подробности

★★★

Проверено: Shaman007 ()
Последнее исправление: red75prim (всего исправлений: 3)

Ответ на: комментарий от clover

Некий прогресс по сравнению с желанием заткнуть языком вентилятор уже есть. Но Раст с серебряной пулей ещё путаете.

red75prim ★★★
() автор топика
Ответ на: комментарий от red75prim

Некий прогресс по сравнению с желанием заткнуть языком вентилятор уже есть. Но Раст с серебряной пулей ещё путаете.

попытка выдать затыкание кулера языком за прогресс - это исключительно прерогатива растосообщества

clover
()
Ответ на: комментарий от clover

Да. Память кончилась - разматываем стек и досвидули, где же тут решето? Ведь нам ничего из данных не попортили и ничего не спёрли.
Ты про ту DoS атаку, что сетевая DoS атака? Может расскажешь мне где тут связь?

Deleted
()
Ответ на: комментарий от Deleted

Да. Память кончилась - разматываем стек и досвидули, где же тут решето? Ведь нам ничего из данных не попортили и ничего не спёрли. Ты про ту DoS атаку, что сетевая DoS атака? Может расскажешь мне где тут связь?

н-да, ты не знаешь что такое DoS, но пытаешься тут дискутировать о безопасности..)

clover
()
Ответ на: комментарий от clover

Да кто бы говорил, сам то тоже рассказать не можешь 0/

Deleted
()

Внутри супер-быстрого CSS-движка: Quantum CSS

https://habrahabr.ru/post/336722

Вы возможно слышали о Project Quantum… Это проект по существенной переработке внутренностей Firefox с целью ускорить браузер. По частям мы внедряем наработки нашего экспериментального браузера Servo и значительно улучшаем остальные элементы движка.

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

Чтобы распределить работу более равномерно Quantum CSS использует технику под названием «воровство работы» (work stealing). Когда узел DOM обрабатывается, программа берет его прямые дочерние элементы и разделяет их на одну или несколько «единиц работы» (work unit). Эти единицы работы ставятся в очередь.

В большинстве браузеров будет сложно реализовать это правильно. Параллелизм — это заведомо сложная задача, а CSS-движок достаточно сложный и сам по себе. Он также находится между двумя другими самыми сложными частями движка рендеринга — DOM и разметки. В общем, ошибку допустить легко, и распараллеливание может привести к достаточно трудноотловимым багам, под названием «гонки данных» (data races). Я описываю эти баги подробнее в другой статье (есть и перевод на русский).

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

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

anonymous
()

ориентированный на безопасность

Очень широкое понятие - безопасность. Какую именно безопасность?

anonymous
()
Ответ на: комментарий от pftBest

Так а шо вы предлагаете? Продолжать ловить сегфолты или переползать на языки с GC?

раст не решает те проблемы о решении которых заявляет сообщество языка(безопасное системное программирование). на этом точка. при этом сам по себе язык возможно мог бы стать очень неплохим для задач веб-бекенда.

clover
()
Ответ на: комментарий от Deleted

какой наркоман будет делать такую кучу на столько мелких объектов да при том специально в таком порядке?

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

В расте абузят RAII и стараются не выделать/освобождать в куче когда не надо.

Можно подробнее и с расшифровкой?

Можешь, как и в Джавке, абузить пул, но для других целей.

Имхо, самописный сборщик мусора понизит скорость ниже нижнего края Джавы. Съест главное преимущество.

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

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

anonymous
()
Ответ на: комментарий от clover

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

Deleted
()
Ответ на: комментарий от anonymous

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

барабанная дробь, алхимия, вечный двигатель. еще и с гарантией небось?)

clover
()
Ответ на: комментарий от anonymous

servo

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

siropchik
()
Ответ на: комментарий от anonymous

это прям как замена сегфолтов на панику

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

NextGenenration ★★
()
Ответ на: комментарий от clover

еще и с гарантией небось?

А gcc гарантирует тебе правильно бинарь собрать?

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

Race conditions могут быть, от них раст не спасает, но data races не будет.

pftBest ★★★★
()
Ответ на: комментарий от makoven

Ничего больше не должен, но факт остается фактом

Тут преподносят факты с таким видом, как будто открыли америку

NextGenenration ★★
()
Ответ на: комментарий от anonymous

1. Разве? Его вроде как создавали скорее ради распаралеливания и, как следствия, ускорения огнелиса.
2. Можно, но смотря с чем сравнивать. С плюсами особой разницы нет, эти идеи оттуда и взяты. Выделение памяти на стеке и её же освобождение при выходе из функции. Замена содержимого объекта в куче без создания второго объекта в куче.
3. Пул - это таки не сборщик мусора, но я мало чего могу сказать про его эффективность.
4.Вроде того.


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

А есть ли какое-то подтверждение что это именно фрагментация, а не текучий скрипт? И да, у меня ФФ неделями висит, но заметных проблем нет. Просто личный опыт, не объективщина.

Deleted
()
Ответ на: комментарий от makoven

В reddit постоянные нападки на tokio из-за его чрезмернейшей сложности и непонятности

Если что-то не критикуют за сложность, будут критиковать за примитивность.

NextGenenration ★★
()
Ответ на: комментарий от makoven

В reddit постоянные нападки на tokio из-за его чрезмернейшей сложности и непонятности

Там даже на ; жалуются. Так себе показатель.

RazrFalcon ★★★★★
()
Ответ на: комментарий от anonymous

Как в нём с фрагментацией памяти? Пример (). Создаём 3 массива: 10, 10 и 20 байт. Через какое-то время освобождаем 1-й и 3-й. Повторяем многократно, чуть увеличивая размер массивов. Через какое-то время у нас свободно 75% памяти, но негде разместить 3-й массив.
Как Rust избегает подобных ситуаций?

Разве для предотвращения фрагментации памяти обязателен gc?

NextGenenration ★★
()
Ответ на: комментарий от NextGenenration

Мне бы было интересно узнать как это сделать без него (Без сарказма, действительно).

Deleted
()
Ответ на: комментарий от NextGenenration

Разве для предотвращения фрагментации памяти обязателен gc?

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

Впрочем вру, GC тут не при чём. Зависит от того перемещающий это менеджер памяти или нет.

red75prim ★★★
() автор топика
Последнее исправление: red75prim (всего исправлений: 3)
Ответ на: комментарий от clover

раст не решает те проблемы о решении которых заявляет сообщество языка(безопасное системное программирование).

Хоть один пруф будет?

NextGenenration ★★
()
Ответ на: комментарий от clover

сам по себе язык возможно мог бы стать очень неплохим для задач веб-бекенда

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

bread
()
Ответ на: комментарий от pftBest

Фичи раста на самом деле реализуемы и в с++. А вот в обратную сторону это неверно.

Безопасно работать с буферами можно и без раста. У меня вообще сегфолтился только qt пятый до 5.9 изза бага в нем. То что проектируется нормально не падает.

ckotinko ☆☆☆
()
Ответ на: комментарий от NextGenenration

Разве для предотвращения фрагментации памяти обязателен gc?

Более того, фрагментация вообще не имеет отношения к gc.

O02eg ★★★★★
()
Ответ на: комментарий от anonymous

Это понятно, но во всех нормальных языках функция sort гарантирует отсортированность, а для устойчивой сортировки есть функция, в названии которой указывается, что она устойчива. Писать sort, если нужно отсортировать устойчиво, и sort_unstable, если требуется просто отсортировать — очень странно в любом случае.

Softwayer ★★
()
Ответ на: комментарий от red75prim

Для этого слаб есть. Там проблема скорее в закомпакивании памяти.

ckotinko ☆☆☆
()
Ответ на: комментарий от bread

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

нуачо, GC нет, лучше Go, кмк пилить бекенд самое то

clover
()
Ответ на: комментарий от RazrFalcon

Паттерн матчинг там с макросами и какой-то матерью реализован в библиотеках. А вот времена жизни полностью запихнуть в С++ не получится.

red75prim ★★★
() автор топика
Последнее исправление: red75prim (всего исправлений: 1)
Ответ на: комментарий от Deleted

https://github.com/solodon4/Mach7


#define MatchF(s) {                                                            \

        XTL_MATCH_PREAMBULA(s)                                                 \

        static_assert(has_member_kind_selector<mch::bindings<source_type>>::value, "Before using MatchF, you have to specify kind selector on the subject type using KS macro");\

        mch::lbl_type __kind_selector = mch::original2remapped<source_type>(mch::tag_type(mch::kind_selector(subject_ptr))), __most_derived_kind_selector = __kind_selector;\

        XTL_UNUSED(__most_derived_kind_selector);                              \

        const mch::lbl_type* __kinds = 0;                                      \

        XTL_CONCAT(ReMatch,__LINE__):                                          \

        switch (size_t(__kind_selector)) {                                     \

        default:                                                               \

            if (XTL_LIKELY(!__kinds))                                          \

            {                                                                  \

                XTL_PRELOADABLE_LOCAL_STATIC(std::vector<const mch::lbl_type*>,__kinds_cache,match_uid_type,XTL_EMPTY());\

                if (XTL_UNLIKELY(size_t(__kind_selector) >= __kinds_cache.size()))\

                    __kinds_cache.resize(__kind_selector+1);                   \

                __kinds = __kinds_cache[__kind_selector];                      \

                if (!__kinds)                                                  \

                    __kinds = __kinds_cache[__kind_selector] = mch::get_kinds<source_type>(__kind_selector);\

            }                                                                  \

            XTL_ASSERT(xtl_failure("Base classes for this kind were not specified",__kinds));\

            XTL_ASSERT(xtl_failure("Invalid list of kinds",*__kinds==__kind_selector));      \

            __kind_selector = __kinds ? *++__kinds : mch::lbl_type(0);         \

            goto XTL_CONCAT(ReMatch,__LINE__);                                 \

        case 0: break; { XTL_SUBCLAUSE_FIRST
red75prim ★★★
() автор топика
Последнее исправление: red75prim (всего исправлений: 1)
Ответ на: комментарий от red75prim

Говорят что если прикрутить сбоку тулзу, то кое как работает.

pftBest ★★★★
()
Ответ на: комментарий от red75prim

Скачал сорцы - 40к строк. Ппц.

Мало того, что выглядят как жуть, так ещё и дорогие.

RazrFalcon ★★★★★
()
Ответ на: комментарий от Deleted

А накуа тогда он?

Ну это же делается и в с++. Если конечно проектировать софт а не писать как сотона повелит.

Запили по сути язык для умученых скрамом и работой с чужим кодом удаленщиков

ckotinko ☆☆☆
()

За счет чего этот ваш rust позволяет безопаснее кодить? Может trade off какие или язык лёгок для статического анализа? Киньтись статьей.

Deleted
()
Ответ на: комментарий от ckotinko

У меня не было проблем с написанием многопоточного кода и сегфолтами в плюсах, но тем не менее я чувствую себя спокойнее, когда это проверено компилятором. Да и сам язык в разы приятнее плюсов, хотя некоторых фич и не хватает (пока).

Deleted
()
Ответ на: комментарий от Deleted

Статический анализатор по сути является частью языка. Trade offs - сложнее заставить программу скомпилироваться.

red75prim ★★★
() автор топика
Ответ на: комментарий от theNamelessOne

Он больше не пришет, я подложил ему в еду яд! ;D

Deleted
()
Вы не можете добавлять комментарии в эту тему. Тема перемещена в архив.