LINUX.ORG.RU

Rust 1.19

 


3

8

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

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

$ rustup update stable

В противном случае, вы можете получить rustup с соответствующей страницы на нашем вебсайте и проверить детальные примечания к выпуску для 1.19.0 на Github.

Что нового в 1.19.0 stable

Rust 1.19.0 получил некоторые долгожданные возможности, но для начала примечание для наших пользователей Windows. На Windows Rust полагается на link.exe для линковки, который вы можете получить из “Microsoft Visual C++ Build Tools.” С последним выпуском Visual Studio 2017, структура каталогов для этих инструментов изменилась. Таким образом, чтобы использовать Rust, вы должны придерживаться инструментов 2015 или использовать обходной путь (такой как запуск vcvars.bat). В 1.19.0 rustc теперь знает, как найти инструменты 2017, и они работают без использования обходных путей.

А теперь к новым возможностям! Rust 1.19.0 это первый выпуск, который поддерживает объединения (unions):

union MyUnion {
    f1: u32,
    f2: f32,
}

Объединения это вид перечислений (enums), но в отличие от последних они «непомечены» («untagged»). Перечисления имеют «пометку», которая хранит информацию, какой вариант является правильным в рантайме; объединения игнорируют эту пометку.

Так как мы можем интерпретировать данные, хранящиеся в объединении, используя неправильный вариант, и Rust не может проверить это для нас, это означает, что чтение или запись поля объединения является unsafe:

let u = MyUnion { f1: 1 };

unsafe { u.f1 = 5 };

let value = unsafe { u.f1 };

Сопоставление с образцом также работает:

fn f(u: MyUnion) {
    unsafe {
        match u {
            MyUnion { f1: 10 } => { println!("ten"); }
            MyUnion { f2 } => { println!("{}", f2); }
        }
    }
}

Когда полезны объединения? Одним из основных случаев использования является интероперабельность с Си. C API могут использовать объединения, и во многих областях часто это делают, и с появлением объединений в Rust написание оберток для API подобных библиотек становится значительно проще. Дополнительно, из этого же RFC:

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

Эту возможность уже давно ждали, и еще больше улучшений на подходе. Сейчас объединения могут только содержать Copy типы и не могут реализовывать Drop. Мы ожидаем снятия этих ограничений в будущем.

Также циклы loop теперь имеют возможность возвращать значение при выходе с break:

// old code
let x;

loop {
    x = 7;
    break;
}

// new code
let x = loop { break 7; };

Rust традиционно позиционируется как «язык, ориентированный на выражения», в котором большинство вещей являются выражениями, вычисляющимися в значения, а не директивами. Раньше loop странно выделялся, так как был директивой.

Что насчет других форм циклов? Здесь еще не всё ясно. Посмотрите этот RFC для ознакомления с некоторыми дискуссиями вокруг открытых вопросов.

Замыкания, которые не захватывают окружение, теперь могут быть приведены к указателю на функцию:

let f: fn(i32) -> i32 = |x| x + 1;


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

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

Наибольшей новой библиотечной возможностью являются макросы eprint! и eprintln!. Они работают так же, как и print! и println!, но пишут в стандартный поток ошибок, а не в стандартный поток вывода.

Другие нововведения:

.

И некоторые недавно стабилизированные API:

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

Cargo

Cargo в основном получил небольшие, но значимые улучшения в данном выпуске. Так, Cargo больше не проверяет локальный рабочий каталог для индекса crates.io. Это должно обеспечить меньший размер файла для реестра и улучшить время клонирования, особенно на машинах Windows.

Другие улучшения:

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

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

★★★★★

Проверено: Shaman007 ()
Последнее исправление: Virtuos86 (всего исправлений: 3)
Ответ на: комментарий от Deleted

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

Ну это и не его проблема. Это проблема того, кто не может ее использовать.

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

Намекаю, что даже в дико древнем и стабильном (т. к. в среднем говно мамонта) C++ эта проблема есть и периодически вылезает.

Если что, Dual ABI в libstd++ используется в GCC5. И тому же CentOS/RHEL 7 ещё только предстоит переезд и пересборка всего мира против нового ABI (там GCC 4.8.x). Debian в 9 таки переехал на 6.3.x, а в 8 так и остался примороженный 4.8.x/4.9.x.

IIRC в плюсовом мире с этим долго жили и не думали о наличии какой-либо проблемы. А в современном мире разработчики rust'а в курсе проблемы и работают над ней.

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

В Rust указатель не может быть NULL

Может: std::ptr::null(). У вас мысль неверно сформулирована.

Передача замыканий в качестве аргументов функции

Есть в плюсах.

Офигенское устройство контейнеров и модулей

Справедливости ради, почти такое же, как и у python.

На самом деле вы самые примитивные вещи описали. Глубже всё ещё лучше.

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

Не считал, но это уже 19-я типа стабильная версия. Ну ниче себе, сколько еще надо?

Всего два года прошло. Время измеряется не в версиях.

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

Специально не будет поддерживать. Тебе на зло.

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

Не напомните, через сколько десятков лет у плюсов abi стабилизировалось?

Разве оно вообще стабилизировалось? С каждым обновлением gcc советуют пересобирать весь мир в gentoo.

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

И где тут указатели в js? Это же C/C++

Ну. С/С++ указатели в js. А ты что хотел увидеть?
Смотри, я дёргаю функцию из libtcod, она выделяет память, возвращает мне указатель. Я этот указатель передаю в js код, чтобы потом передавать его обратно и дёргать с ним другие функции. В js с указателем теоретически может происходить что угодно, т.к. это просто uint64. Его могут сложить с чем-нибудь или просто похерить. Rust как-нибудь умеет следить за указателями, полученными от внешних либ?

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

Офигенское устройство контейнеров и модулей

Справедливости ради, почти такое же, как и у python.

В Питоне модульная система привязана к ФС. И это ее недостаток. В Расте скорее как в Руби.

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

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

Ты этот указатель передаёшь в Duktape код(на крестах), чтобы потом передавать его обратно и дёргать с ним другие функции, так?

Rust как-нибудь умеет следить за указателями, полученными от внешних либ?

В пределах твоего кода. Если к примеру Duktape решит освободить память, но тебе об этом не скажет, то в этом случае rust тебе не поможет. Если речь идёт только о твоём коде, то да.

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

В пределах твоего кода. Если к примеру Duktape решит освободить память, но тебе об этом не скажет, то в этом случае rust тебе не поможет. Если речь идёт только о твоём коде, то да.

Если я взял себе указатель на что-то, то никто него не будет трогать, и так, как rust может помочь?

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

Сильно ломали с GCC 4.x на 5.x, а дальше большой боли не помню.

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

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

Может: std::ptr::null(). У вас мысль неверно сформулирована.

std::ptr::null() - это же вроде для сырых указателей?! Вообще, я имел ввиду, что вместо NULL\Nil используется Enum с None в Option<T>

На самом деле вы самые примитивные вещи описали. Глубже всё ещё лучше.

Так я в конце списка об этом и сказал, что это плюшки лежат на поверхности

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

О том и спич. Если человек за 4 года участия в «растосрачах», как он выразился, не способен запомнить, что rust только недавно зарелизил 1.0, то как с ним о таких серьёзных материях как ABI можно разговаривать?

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

Такое себе «достоинство»

А чем плохо что Вы вольны указывать зависимости из следующих источников?

  • Локальной директории
  • С удалённого источника
  • Просто имя крэйта с cargo.io
AntonyRF ★★★★
()
Ответ на: комментарий от AntonyRF

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

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

В числовые константы можно вставлять подчеркивания. Удобная штука, 0xffff_ffff_ffff_ffff_ffff_ffff

Киллер-фича, на втором месте!

Компактные имена базовых типов - u16, i32, i64

Освой уже слепую печать. Обфускации ради людей, которым лень печатать и которые, по видимому, не умеют в IDE - это зло. Давай типы обозначать буквами алфавита? Если брать оба регистра - получится 52 типа данных. И печатать недолго, максимум 2 клавиши нажать надо.

В Rust нельзя получить висячие указатели

Не надо пускать в системное программирование людей, которые их создают. Гнать ссаными тряпками. Или платить нормальную зарплату, чтобы на работу системщиками не шли люди «от сохи».

И да, временное существование указателя (который просто число по сути), указывающего куда-то не туда - не трагедия, если по нему никто не думает обращаться. Чем плохо то, что одна переменная-указатель может использоваться для разных динамически выделяемых кусков памяти? Да ничем! Проблемы у вас в голове.

В нём мощное обобщённое программирования.

Нихрена не понял. Это вы про дженерики-то. Ну да, для вас сделали на блюдечке те же самые генерирующие макросы - это очень круто.

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

Есть и в Си что-то вроде, но тут можно делать так

let - это вообще какой-то лютый отстой, от него даже в BASIC отказались (собственно, он там по-моему и появился изначально). На типах данных экономия, а на присваиваниях - обязательно нужно дурацкое словечко с пробелом! Даже в R разрещено использовать «=» вместо «<-» - и никаких летов.

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

А в современном мире разработчики rust'а в курсе проблемы и работают над ней.

Спасибо, почитал. Увидел что без разделения на «заголовочники» и «исходники» проблемы раста не решаются. Надо ждать, когда договорятся и, абсолютно все поломав, добавят. Я так думаю, не раньше версии 2.0

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

Не ушла. Смотри ченчлоги, раздел о совместимости.

Посмотрел, в основном правят косяки которые в прошлых версиях пропускал компилятор

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

Шта?! Что за поток мыслей? Можете по человечески написать?

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

Не ушла. Смотри ченчлоги, раздел о совместимости.

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

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

Шта?! Что за поток мыслей? Можете по человечески написать?

От тебя пользы нет. Зачем тебе объяснять? Вот grossws все понял и дал полезную ссылку. Иди в Игнор.

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

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

Тогда в системном программировании не останется программистов.

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

Увидел что без разделения на «заголовочники» и «исходники» проблемы раста не решаются.

Это всего лишь одно из мнений. Другое — распространение библиотек в формате MIR (когда его стабилизируют) и фиксированный LLVM.

Тогда эти библиотеки можно будет спокойно линковать (и выполнять другие rust-специфичные вещи типа мономорфизации дженериков) для получения ABI-совместимого .so-шника.

Естественно, в таком варианте ABI будет фиксировать версию LLVM из дистрибутива (как сейчас происходит с glibc, libstdc++ и GCC) в которой фиксируется MIR backend (frontend с точки зрения LLVM), а версия rustc (той части, что компилирует в MIR) может спокойно меняться от библиотеки к библиотеке, как сейчас происходит с C++.

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

Если я взял себе указатель на что-то, то никто него не будет трогать, и так, как rust может помочь?

Отвечать на вопрос, когда ответ доступен в мануале скучно. Сказанно же: следить за твоим кодом.

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

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

Тем временем железячники-радиолюбители прошивают код в котором не разбираются.

Или платить нормальную зарплату, чтобы на работу системщиками не шли люди «от сохи».

И что за магию содержат в себе купюры? Как её извелчь из них?

Чем плохо то, что одна переменная-указатель может использоваться для разных динамически выделяемых кусков памяти? Да ничем!

Что? Разве кто-то возражает?

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

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

let - это вообще какой-то лютый отстой, от него даже в BASIC отказались (собственно, он там по-моему и появился изначально). На типах данных экономия, а на присваиваниях - обязательно нужно дурацкое словечко с пробелом!

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

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

А что должен создавать компилятор, если не испоолняемые файлы?

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

Киллер-фича, на втором месте!

Когда не к чему придраться, надо указать на номер строки? =)

Освой уже слепую печать.

Мимо. Освоил

Обфускации ради людей, которым лень печатать и которые, по видимому, не умеют в IDE - это зло.

И ещё раз мимо, IDE я использую и всяко удобнее писать u32, чем набирать unsigned int, ведь даже с автодополнением получается больше 3-х символов надо нажать на клаве. И ещё ни кто из людей которые программируют на Rust не сказал, что видит что-то плохое в коротких названиях всем известных базовых типов.

Давай типы обозначать буквами алфавита? Если брать оба регистра - получится 52 типа данных. И печатать недолго, максимум 2 клавиши нажать надо.

Так себе аргумент, u16, u32, i16, i32 и т.д. очень броские на вид и не вводят в заблуждения.

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

Но в любом плюсовом проекте, что-то да у кого-то течёт. Это уже настолько стало нормой, что даже есть специальные инструменты чтобы вылавливать утечки памяти =)

И да, временное существование указателя (который просто число по сути), указывающего куда-то не туда - не трагедия, если по нему никто не думает обращаться. Чем плохо то, что одна переменная-указатель может использоваться для разных динамически выделяемых кусков памяти? Да ничем!

И снова мимо =) В Rust можно затенить связывание let. Это значит, что, если объявить связывание с именем, которое уже существует, то оно переопределит предыдущее. Например так

fn main() {
  
  let mut x = 5; // Число 
  let y = &mut x; // Указатель на число
  let y = "text"; // y связан с текстом
}

Проблемы у вас в голове.

Судя по всему у вас проблемы, а не у меня. Ваш мозг не понимает, что проблемы С++ можно решить изящно, так?!

Нихрена не понял. Это вы про дженерики-то.

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

let - это вообще какой-то лютый отстой

let - это не объявление переменной, это связывание переменной с данными.

Ну корче, всем покедова, побежал я домой, рабочий день кончился =)

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

Я же не фанбой помнить какие циферки в каком году у вас были. Раст на лоре форсят давно, срок достаточный, чтобы хоть что-то работающее предъявить. А на деле все вы кульхацкеры на работе пишете рутину на говне мамонта. Ваш главный евангелист тылганер вот признавался, что и десятка строк на расте не написал. Сама по себе ситуация смешная: сидят погромисты и ждут стабилизации своей прелести, перетирают уберфичи и меряются хеловордами. Вот уже 19 версий стабильных, ниче не меняется.

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

Да хоть 10 лет. На си за 10 лет много написали?

Ну посчитай все коммиты в крупные открытые проекты на Си. Да, много. Нового не пишут? Вот так сюрприз, люди предпочитают дорабатывать уже готовое, кто бы мог подумать.

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

Я же не фанбой помнить какие циферки в каком году у вас были

Ты фанбой размахивать циферками которые взяты с потолка. Откуда-то же взял 4 года.

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

Вот на этом месте я узнал о расте: Rust 0.7. Потом было много веселых срачей, где половина постов анонимуса выпилена тылгунером.

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

Отвечать на вопрос, когда ответ доступен в мануале скучно.

Сперва надо попробовать понять, что от тебя хотят.

Сказанно же: следить за твоим кодом.

У меня нет кода. Выделение памяти происходит в сторонней библиотеке, в си коде он нигде не фигурирует. Когда он нужен его получают путём преобразования *void в нужный тип, который в свою очередь получают из js кода. Доступно объяснил? Вопрос, есть ли смысл юзать жравого или проще написать какой-нибудь свой список с указателями, чтобы проверять, что приходит из js кода?

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

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

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

Удалённый источник имеет свойство протухать.

У автора? Поменяй на того кто его форкнул

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

Не отличаешь объявление с присвоением от присвоения?

Во первых, присваивание.

Во-вторых объявление вида «let a» - это что-то за гранью добра и зла. Переводится как «Пусть А...»

Ржавчину наркоманы писали что ли?

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

У меня лично рвёт от его гопнического синтаксиса. Видно, что язык для тех, кому некогда, нужно х-х-продакшн, и тут уж некогда думать - суй в ж*пу огурец.

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

Во первых, присваивание.

a = 6 // присваивание

Во-вторых объявление вида «let a» - это что-то за гранью добра и зла. Переводится как «Пусть А...»

Совсем уже придратся не к чему? Ты уже приводил пример инициализации переменной. 7 строк. И ты ещё продолжаешь говорить об удосбтве?

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

Раз не будут - идут лесом.

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

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

Это запилили задолго до раста, смотри CPAN, gem и т.п. Кто ж виноват, что у тебя розовые очки

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

Во-вторых объявление вида «let a» - это что-то за гранью добра и зла. Переводится как «Пусть А...»

Ржавчину наркоманы писали что ли?

За гранью добра и зла узкая напрвленность твоего кругозора. Про Бейсик ты в курсе, а то, что «let» используется для биндинга переменных во многих ML-подобных ЯП, тебе не ведомо.

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

Удалённый источник имеет свойство протухать.

Это правда =\

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

Во-первых удобство и количество строк коллерируют разве что у тех, кому пальцы дверью прищемило. Во-вторых у меня там к инициализации имели отношение 3 строки, а не 7 (with я показал просто в качестве примера того, чего нет в rust, а надо бы).

a = uint32(6) // тоже вполне себе присваивание 
DRVTiny ★★★★★
()
Ответ на: комментарий от DRVTiny

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

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

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

Если Rust из-за моды на Lisp решил как обезьяна очки на Ж - нацепить оператор let туда, где он даром не нужен - ну что можно сказать...

Только

=(a,6)

ИМХО это имеет хоть какой-то смысл, как и «+*ab/cd», а вот назачем rust'у слово let и почему function сокращено до какого-то огрызка - вот это не вполне понятно.

DRVTiny ★★★★★
()
Последнее исправление: DRVTiny (всего исправлений: 1)
Вы не можете добавлять комментарии в эту тему. Тема перемещена в архив.