LINUX.ORG.RU

Вышел Rust 1.8

 


3

7

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

Как обычно, вы можете установить Rust 1.8 с соответствующей страницы на нашем сайте и посмотреть подробные примечания к выпуску 1.8 на GitHub'е. В этом релизе было принято около 1400 патчей.

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

Этот выпуск содержит два нововведения, и приятный сюрприз для пользователей Windows! Помимо этого идёт работа по замене системы сборки Rust, основанной на make, на Cargo.

Первое нововведение – это возможность перегрузки составных операторов присваивания, таких как += и -=. Изменение было принято в RFC 953 и выглядит следующим образом:

use std::ops::AddAssign;

#[derive(Debug)]
struct Count { 
    value: i32,
}

impl AddAssign for Count {
    fn add_assign(&mut self, other: Count) {
        self.value += other.value;
    }
}   

fn main() {
    let mut c1 = Count { value: 1 };
    let c2 = Count { value: 5 };
    c1 += c2;
    println!("{:?}", c1);
}

Эта программа выведет Count { value: 6 }. Как и в других трейтах, перегружающих операторы, ассоциированный тип позволяет использовать разные типы в левой и правой части оператора (см. RFC 953).

Второе нововведение, взятое из RFC 218, не такое значительное. В предыдущих версиях Rust структура, не содержащая полей, должна была объявляться без фигурных скобок:

struct Foo; // works
struct Bar { } // error

Вторая форма объявления больше не является ошибочной. Изначально эта форма была запрещена из соображений согласованности с другими пустыми объявлениями, а также для предотвращения неоднозначности синтаксического разбора. Но эта неоднозначность была устранена, начиная с Rust 1.0. Кроме того, запрет этой формы создавал трудности при написании макросов, требуя специальной обработки. Наконец, пользователям, ведущим активную разработку, иногда требовалось менять пустую структуру на непустую и наоборот, что требовало лишней работы и приводило к некрасивым diff'ам.

Возвращаясь к Windows — теперь 32-х битные MSVC сборки поддерживают размотку стека, что переводит платформу i686-pc-windows-msvc в класс 1 (о классах поддержки платформ).

Мы с давних пор используем make для сборки Rust'а, но у нас уже есть своё замечательное средство сборки для программ на Rust: Cargo. В Rust 1.8 мы добавили предварительную поддержку новой системы сборки, написанной на Rust и основанной на Cargo. Мы ещё не используем её по умолчанию, и она требует значительной доработки, поэтому подробное её описание появится в примечаниях к выпуску после её завершения. Сейчас вы можете посмотреть подробности по ссылке на PR 31123.

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

В Rust 1.8 около 20 функций и методов было переведено в категорию стабильных. Их можно разбить на три группы: работа со строками в кодировке UTF-16, различные API для работы со временем, и дополнительные трейты, необходимые для перегрузки операторов, упомянутые в секции об изменениях в языке.

Нововведения в Cargo

  • cargo init создаёт проект в текущем каталоге, не создавая новый, как делает cargo new
  • cargo metadata - дополнительная субкоманда для получения метаданных
  • .cargo/config теперь допускает ключи -v и --color
  • Улучшены возможности Cargo по поддержке платформоспецифичных зависимостей.

Подробное описание изменений.

>>> Вышел Rust 1.8

★★★

Проверено: maxcom ()
Последнее исправление: shahid (всего исправлений: 5)

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

Debasher ★★★★★
()

Библиотеками ценен раст. Как не складывающий всё говно в std, ждем стабилизации популярных библиотек. А релизы как-то не особо нужны. Правда реалиция arm-linux как 1 класс поддержки платформ — это было бы неплохо.

Всем кто говорит что у раста вырвиглазный синтаксис: а где пруфы?

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

не моего и не твоего ума дело

Не нужно решать за всех.

а в линуксах GTK/Qt сожрёт ой-ёй-ёй сколько

А в винде mfc и подобные как будто не установлены. Вперед учить матчасть.

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

Всем кто говорит что у раста вырвиглазный синтаксис: а где пруфы?

Любой исходник на Rust откройте и пруфы начнутся.

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

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

Не, у раста две проблемы в плане читаемости: макросы и вот_такие_идентификаторы_с_подчеркиванием. Я заменял if'ы на match по enum'aм и всё становилось читаемее.

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

А ты запомни мой ник. Может это забъёт твою память ненужной информацией.

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

Я не понимаю именно чередование туда-сюда

У меня мало «практического» опыта в расте, но в одном «хело ворлде» сталкивался, что пару итераций проделать пришлось. Тоже сомневаюсь, что эта проблема часто мешается, скорее упомянули чтобы причин больше было.

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

Мужики, а rust-book актуален еще? А то стал читать перед сном, когда дочитаю выйдет уже rust 2.0

Если читаешь оригинал, то его обновляют когда что-то важное появляется. А вот перевод на русский, вроде, на версии 1.2 зафиксирован (сейчас).

Да и язык, в основном, расширяют, а не «меняют».

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

а практически вы будете какие-то элементарные вещи делать в 10 раз дольше, чем программисты на D/C#.

Ну-ну.

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

ждем стабилизации популярных библиотек. А релизы как-то не особо нужны.

Дык, одно от другого «иногда» зависит?..

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

а практически вы будете какие-то элементарные вещи делать в 10 раз дольше, чем программисты на D/C#.

И, конечно, пруфов не будет?

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

Без дополнительных крейтов вроде бы не получается. У Iterator нет метода sort.

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

&mut v[..].sort();

А почему не v.sort()?

for v in &mut v[0..10] {*v *= 2;}

Такое в приличном обществе не пишут в одну строчку.

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

Через итераторы и в одну можно

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

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

v[0..10]

И вообще, почему не v[..10]? Зачем пихать в свой код столько лишней фигни?

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

А почему не v.sort()?

Можно и так, но развернётся в то, что я написал.

Такое в приличном обществе не пишут в одну строчку.

А мы в приличном обществе?

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

Не сложно, в принципе, только в D это выглядит как:

v.sort();
v[0 .. 10] *= 2;
Вопрос теперь в том, что легче читается?

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

Вопрос теперь в том, что легче читается?

Ответ на 90% вопросов о Rust - «потому что язык обеспечивает memory safety без GC».

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

Понятно, что вариант D читается легче. Впрочем перегрузку составных операторов присваивания стабилизировали, так что можно сделать RFC на добавление таких операций со слайсами в стандартную билиотеку. Будет:

&mut v[0..10] *= 2;

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

Ответ на 90% вопросов о Rust - «потому что язык обеспечивает memory safety без GC».

Чем memory safety мешает писать вместо:

&mut v[..].sort();

Вот так:

v.sort();

?

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

Я уже писал, что ничего не мешает. Можно записать и так.

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

Это понятно, отсюда и все эти &mut и прочая мутотень. Но получается очень коряво и сложно. Потому что каждый раз нужно думать, что написать: a, mut a, &a, &mut a? И если есть разница (а всегда ли она есть?), то в чём она? При таком числе вариантов мозг будет занят исключительно тем, чтобы обеспечить это самое memory safety, а не решением прикладной задачи,т.е. не разработкою алгоритма. На мой взгляд, лучше либо GC добавить, либо писать руками, как в чистом C. В конце концов, в Паскале и Фортране нет классического GC, но они позволяют писать сложный и эффективный код, в том числе системного уровня. А на Обероне Вирт написал ОС, причём это был первый язык с GC.

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

Для кого?

Ну ты код выкати, и тогда уж выясним, почему и для кого.

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

Она не мешает:

fn main() {
    let mut vec = vec![1, 2, 3, 4, 5];
    vec.sort();
    vec[0..2].sort();
}

А вот умножить элементы вектора на число без &mut, наверное, невозможно.

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

Компилятор будет занят обеспечением memory safety. А мозгу придётся приноровиться не очень часто её нарушать. Но на это требуется не очень много времени.

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

Вот это и погано. Обе операции: и сортировка, и умножение приводят к изменению вектора, но одна разрешена с mut и без, а другая --- нет. Причём ещё писать надо &mut, а не просто mut.

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

Это понятно, отсюда и все эти &mut и прочая мутотень. Но получается очень коряво и сложно.

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

И еще насчет сложности: http://smallcultfollowing.com/babysteps/blog/2015/12/18/rayon-data-parallelis... Для D такое есть?

Потому что каждый раз нужно думать, что написать: a, mut a, &a, &mut a? И если есть разница (а всегда ли она есть?), то в чём она?

Не понял, что такое mut a, но разница есть. Описана в учебнике.

мозг будет занят исключительно тем, чтобы обеспечить это самое memory safety, а не решением прикладной задачи

Дело в том, что memory safety - это ЧАСТЬ ПРИКЛАДНОЙ ЗАДАЧИ (именно так, капсом).

На мой взгляд, лучше либо GC добавить, либо писать руками, как в чистом C

А на мой, идея добавить туда контроль за памятью кажется блестящей и назревшей (и я профессионально пишу на Си). И кстати, по сравнению с убожеством, которое называт «чистым Си», в Rust есть еще много чего.

В конце концов, в Паскале и Фортране нет классического GC, но они позволяют писать сложный и эффективный код, в том числе системного уровня.

Развитие языков программирования должно было остановиться на Паскале?

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

Обе операции: и сортировка, и умножение приводят к изменению вектора, но одна разрешена с mut и без, а другая --- нет

Не понял, о чем ты.

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

А вот умножить элементы вектора на число без &mut, наверное, невозможно.

А по-моему, возможно. Надо сделать специальный метод, и получится что-то вроде:

vec.map_inplace(|a| a*2);
anonymous
()
Ответ на: комментарий от tailgunner

А на мой, идея добавить туда контроль за памятью кажется блестящей и назревшей (и я профессионально пишу на Си). И кстати, по сравнению с убожеством, которое называт «чистым Си».

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

в Rust есть еще много чего

Та есть ООП, не правда ли!

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

Ты наверно хотел сказать

Нет.

в Rust есть еще много чего

Та есть ООП, не правда ли!

Интерфейсы и их наследование в Rust есть, всё остальное ООП - жвачка для мозгов и тупой маркетинг.

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

Можно и так, но развернётся в то, что я написал.

Нет, ты берёшь mutable reference на результат метода sort. http://is.gd/10tAAV

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

А вот умножить элементы вектора на число без &mut, наверное, невозможно.

Всё-таки можно. Оператор индексирования в позиции lvalue раскрывается в IndexMut http://is.gd/A5kE8J

Нет, ты берёшь mutable reference на результат метода sort.

Да. Ошибся.

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

А вот умножить элементы вектора на число без &mut, наверное, невозможно.

Оператор индексирования в позиции lvalue раскрывается в IndexMut

Насколько я вижу, ты просто переставил &mut в другое место, как анонимус с map_inplace.

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

Ну так неизменяемый слайс на то и неизменяемый. Я так понял, что Vuvod'у не понравился &mut в &mut v[0..10] *= 2;

red75prim ★★★
() автор топика

ЛОР, что с тобой?

Почему я уже две страницы читаю, как примерно адекватные люди спорят про синтаксис?

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

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