LINUX.ORG.RU

Избранные сообщения ozkriff

Rust 1.29

Новости — Mozilla
Группа Mozilla

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

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

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

  • cargo fix автоматически исправляет предупреждения в коде
  • cargo clippy - статический анализатор Rust кода, помогающий поймать распространенные ошибки и просто улучшить код

cargo fix

С выпуском Rust 1.29 у Cargo появляется новая подкоманда: cargo fix. Если вы когда-либо писали на Rust, то скорее всего уже сталкивались с предупреждениями компилятора. Например, рассмотрим такой код:

fn do_something() {}

fn main() {
    for i in 0..100 {
        do_something();
    }
}

В нем мы вызываем do_something сто раз, но никогда не используем переменную i. Rust предупреждает нас об этом:

> cargo build
   Compiling myprogram v0.1.0 (file:///path/to/myprogram)
warning: unused variable: `i`
 --> src\main.rs:4:9
  |
4 |     for i in 1..100 {
  |         ^ help: consider using `_i` instead
  |
  = note: #[warn(unused_variables)] on by default

    Finished dev [unoptimized + debuginfo] target(s) in 0.50s

Видите подсказку о переименовании в _i? Мы можем автоматически применить ее при помощи cargo fix:

> cargo fix
    Checking myprogram v0.1.0 (file:///C:/Users/steve/tmp/fix)
      Fixing src\main.rs (1 fix)
    Finished dev [unoptimized + debuginfo] target(s) in 0.59s

Если теперь мы откроем src\main.rs, то увидим исправленный код:

fn do_something() {}

fn main() {
    for _i in 0..100 {
        do_something();
    }
}

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

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

cargo clippy

Еще о предупреждениях: теперь вы можете попробовать cargo-clippy через Rustup. Clippy это статический анализатор, который выполняет много дополнительных проверок вашего кода.

Например:

let mut lock_guard = mutex.lock();

std::mem::drop(&lock_guard)

operation_that_requires_mutex_to_be_unlocked();

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

Установим предварительную версию Clippy через Rustup:

$ rustup component add clippy-preview

и запустим ее:

$ cargo clippy
error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
 --> src\main.rs:5:5
  |
5 |     std::mem::drop(&lock_guard);
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: #[deny(drop_ref)] on by default
note: argument has type &std::result::Result<std::sync::MutexGuard<'_, i32>, std::sync::PoisonError<std::sync::MutexGuard<'_, i32>>>
 --> src\main.rs:5:20
  |
5 |     std::mem::drop(&lock_guard);
  |                    ^^^^^^^^^^^
  = help: for further information visit https://rust-lang-nursery.github.io/rust-clippy/v0.0.212/index.html#drop_ref

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

Обратите внимание, что это только ознакомительная версия; Clippy еще не достиг 1.0, поэтому набор и поведение проверок еще могут меняться. Мы выпустим компонент clippy, как только он будет стабилизирован, а пока просим вас посмотреть на деле предварительную версию и рассказать нам о своем опыте.

Да, есть еще нюанс: к сожалению, пока что нельзя использовать clippy вместе с cargo-fix. Работа над этим ведется.

Подробности смотрите в примечаниях к выпуску.

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

В этом выпуске были стабилизированы следующие API:

Также, теперь вы можете сравнивать &str и OsString.

Подробности смотрите в примечаниях к выпуску.

Улучшения в Cargo

Выше мы уже описали две новые подкоманды Cargo. Так же, Cargo теперь будет автоматически пытаться починить Cargo.lock файлы, испорченные git mergeом. Это поведение можно отключить флагом --locked.

cargo doc обзавелся новым флагом: --document-private-items. По умолчанию, cargo doc документирует только публичные части API, потому что предназначен для генерации пользовательской документации. Но если вы работаете над своим пакетом и в нем есть внутренняя документация, то --document-private-items включит генерацию документации вообще для всего.

>>> Примечания к выпуску

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

 ,

ozkriff
()

На Rust запилили Coroutine, Go можно выкидывать?

Форум — Development

Мониторю гитхаб тренды по расту, вот такое поделие обнаружилось https://github.com/zonyitoo/coio-rs С растом слабо знаком, особо не разбирался, но как я понимаю «Work-stealing coroutine scheduling» тоже самое как и в goroutine?

 ,

foror
()

glium - безопасная обертка над OpenGL на Rust

Форум — Development

Томака написал довольно развернутый пост о своей библиотеке - https://medium.com/@tomaka/the-glium-library-5be149d87dc1.

glium - безопасная обертка средней толщины над OpenGL на Rust.

https://github.com/tomaka/glium

Цели glium:

  • Автоматическое управление многими тонкостями OpenGL, которые при неправильном использовании могли бы привести к падениям.
  • Предоставление интерфейса, который навязывает хорошие практики, вроде RAII или отсуствия состояния.
  • Совместимость со всеми версиями OpenGL, где есть шейдеры, и сглаживание различий между ними.
  • Раннее обнаружение ошибок. В идеале - во время сборки.
  • Оптимизация/реорганизация порядка вызовов OpenGL и упрощение использования современного OpenGL.

Даже несколько сыроватых уроков есть - 1, 2, 3.

Комменты к посту в реддите - /r/rust, /r/programming

Лично я им пока особо не пользовался, но подумываю заменить им часть своих кривых наколенных оберток над голым gl-rs. С виду оно немного громоздкое (хотя это вина OpenGl`ей) и долго собирается, но интересное. И, что важно, Томака активно занят его развитием.

Этот же чувак написал, например, glutin - альтернативу sdl/glfw на ржавчине и hlua - привязки к Lua.

Отзыв Томаки о ржавчине - https://internals.rust-lang.org/t/production-user-research-summary/2530/9. Кстати, там вообще интересное обсуждение.

 , , ,

ozkriff
()

Вышел Rust 1.2

Новости — Open Source
Группа Open Source

7 августа вышел очередной стабильный релиз Rust 1.2 — языка программирования общего назначения, разрабатываемого Mozilla совместно с сообществом. Данный релиз сохраняет полную обратную совместимость с Rust 1.0, вышедшим в мае этого года.

Основные изменения:

( читать дальше... )

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

 , ,

nonimous
()

как rust захватывает ссылки

Форум — Development

Предположим, есть такой код

fn f(x : Box<i32>) -> Box<i32> {
	if some_random_value {
		return x;
	} else {
		return Box::new(10);
	}
}


fn g() -> Box<i32> {
	let x = Box::new(20);
	return f(x);	
}

fn main() {
	let a = g();
}

Как раст понимает, что после вызова g() память, выделенную под Box::new(20), надо освободить? Ведь, насколько я понимаю, в зависимости от случайного события (some_random_value) Box::new(20) надо либо удалить после g(), либо вернуть как результат

 

jcdr
()

Вышел Rust 1.0

Новости — Open Source
Группа Open Source

15 мая 2015 года, в соответствии с планом, вышел публичный релиз Rust 1.0 - языка программирования общего назначения, разрабатываемого Mozilla совместно с сообществом. Язык ориентирован на разработку безопасных и эффективных приложений, имеет развитую систему типов, оптимизирующий кодогенератор на основе llvm и предоставляет расширенные гарантии потокобезопасности и безопасного доступа к памяти без использования сборщика мусора. В частности, Mozilla использует Rust для разработки браузерного движка следующего поколения servo.

( читать дальше... )

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

 , ,

nonimous
()

Запилите, кто-нибудь, новость про Rust.

Форум — Development

Собственно, больше сказать нечего.

 

nezamudich
()

Приоритеты развития Rust после 1.0

Форум — Development

Опубликован план развития ЯП Rust после выхода версии 1.0, назначенной на май 2015 года, фанбоям и хейтерам будет одинакового интересно ознакомиться.

Задачи с высшим приоритетом:

  • Расширение стандартной библиотеки, в частности Filesystem APIs и Memory allocation APIs.
  • Улучшение поддержки ARM и Windows.
  • Ускорение компиляции, в частности добавление параллельной компиляции.
  • Упрощение распространения написанных на Rust приложений и библиотек, в частности реализация cargo install.
  • Расширение поддержки инструментария, в частности отладчиков и профайлеров, по возможности используя применяемые в С инструменты.
  • Реализация динамических деструкторов(?), что позволит избежать расходов на обнуление памяти при освобождении объектов.
  • Улучшенная поддержка аллокаторов.
  • Специализация трейтов, по типу специализации шаблонов в С++.
  • Виртуальные структуры - вариант реализации наследования.

Задачи с высоким приоритетом:

  • Улучшения в borrow checker'e.
  • Улучшения в макросах, в частности лучшая интеграция с модульной системой.

Некоторые долгосрочные задачи:

  • Передача типов с динамическим размером по значению.
  • Параметризация дженериков целочисленными значениями.
  • async/await/yield .
  • Типы высшего порядка.

 , ,

nonimous
()

Чисто технические причины НЕ любить Rust [holywar mode activated]

Форум — Development

Я тут на досуге посидел с ручкой-бумажкой и выписал штук 10 чисто технических причин, почему Rust, как язык, совершенно ни на что не годится и не нужно тратить время на его изучение. Чисто технических - в смысле, не включающих в себя пункты про отсутствие нормальной IDE, малый размер сообщества, и тому подобные. Не знаю, насколько это кому-то интересно, но предлагаю провести эксперимент. Напишите в комментариях свою версию этих пунктов, а потом сравним. Есть серьезные подозрения, что в Rust намного больше недостатков чисто с точки зрения дизайна языка, чем мне сейчас приходит на ум. Но как с любой другой новой технологией, евангелисты сосредоточены исключительно на преимуществах, закрывая глаза на недостатки.

 , ,

afiskon
()

Рогалики

Форум — Games

Тред для обсуждения всех возможных рогаликов. Как свободных, так и нет, как с графикой, так и ASCII, как каноничных, так и более современных hack'n'slash-ей.

Основные современные рогалики: Angband, Nethack, ADOM, Crawl, ToME.

Классические рогалики: Rogue (родоначальник жанра), Hack, Moria, Larn, Omega.

Множество других рогаликов описано на roguebasin.com

buddhist
()

приведение нативных указателей в rust

Форум — Development
/home/sh/rust/windowmanager/src/x11/mod.rs:146:19: 146:43 error: mismatched types:
 expected `*mut libc::types::common::c95::c_void`,
    found `*mut libc::types::common::c95::c_void`
(expected enum `libc::types::common::c95::c_void`,
    found a different enum `libc::types::common::c95::c_void`) [E0308]
/home/sh/rust/windowmanager/src/x11/mod.rs:146             XFree(self.data as *mut c_void);

не очень понятно, чем его не устраивает c_void вместо другого c_void

как это вообще можно интерпретировать?

 ,

MyTrooName
()

Кто-нибудь собирал rust 1.0 и cargo на gentoo?

Форум — General

Захотел тут собрать, но что-то оно не собирается :)

Может кто смог это сделать?

 , , , , никто не читает теги

deterok
()

Альфа-версия Rust 1.0

Новости — Open Source
Группа Open Source

9 января тихо и незаметно вышла альфа-версия Rust 1.0. Этот релиз является этапным в том смысле, что набор возможностей языка зафиксирован и в версиях 1.x значительных несовместимых изменений больше не будет (см. ниже); то же относится и к стандартной библиотеке. Гарантии стабильности означают, что Rust уже можно изучать, не опасаясь скорого устаревания полученных знаний из-за эволюции языка.

Тем не менее, апгрейд в линии от альфа-версии до финальной версии может вызвать мелкие несовместимости (Sync/Send changes, переименование uint/int в usize/isize), но все проблемы планируется решить до выпуска 1.0.

Основные изменения со времени предыдущего релиза:

  • улучшенная поддержка массивов и подобных им контейнеров в языке: DST
  • унификация трейтов и замыканий в виде unboxed closures: теперь замыкания - это просто объекты, реализующие определенные трейты

Полный список изменений с подробным их описанием по ссылке:

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

 

tailgunner
()

модульность в rust

Форум — Development

Скажите как в расте скормить компилятору несколько библиотек. Я пишу модуль, например mud.rs компилю его с ключем "--crate-type lib". Получаю libmod.rlib. Затем пускаю собирать другой модуль с ключем "-L путь-до-спапки-с-первым-модулем". Но компилер все равно ругается на импорт «use mod::*». Что я делаю не так?

 

Aswed
()

типы указателей в расте

Форум — Development

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

struct store{a : &int}
и записать в них один указатель. GC с ним не работает, так как время жизни известно на этапе компиляции.
Есть указатель Box<int> я могу создать такой указатель внутри блока и делать с ним все, что угодно, но в конце блока все копии этого указателя должны быть удалены и сам указатель освободится. GC эти указатели тоже не трогает, так как время освобождения известно.
Есть указатель ~int. Это обычный указатель на объект в куче. Время жизни неизвестно, за ним следит GC.
Я правильно понял, как работать с этими указателями? Есть тут еще какие-то типы или только эти 3? Что за указатель *mut int?

 , ,

Aswed
()

Почему вы так фапаете на этот Rust?

Форум — Development

Да, много фич, очередной «убийца С++».
Но не взлетит же, согласитесь!
Так же, как не взлетел Nemerle и иже с ним.

 

Progressive
()

Сравнение Rust и C++ на примере трассировщика путей

Форум — Development

Тут как-то была тема про то, что хочется нормальное сравнение C++ и Rust. Вот эта серия статей, как мне кажется, вполне себе кандидат:

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

Разработка трассироващика путей на Rust`е, часть 7: Заключение

Чтобы изучить Rust, я портировал свой спекртальный трассировщик путей Luculentus на язык Rust. Результат я выложил на Github. В процессе я также немного обновил Luculentus, переведя его на более современный C++. Детали вы можете прочитать в прошлых постах. В этом же посте я хочу подвести итоги и сравнить результаты.

Картинка

Для начала, пример вывода трассировщика путей! Захардкоженная сцена выглядит вот так:

http://ruudvanasseldonk.com/images/robigo-luculenta.png

Если вам интересно что-то в ней изменить, то смотрите set_up_scene в app.rs.

Начало работы с Rust

В настоящий момент, вы можете установить компилятор Rust`а и Cargo за пару минут, даже в Windows. Да и заставить их работать было намного проще, чем, например, Scala и sbt.

Сообщество Rust`а показалось мне очень дружелюбным. Когда я не знал что делать, мне очень помогали IRC канал и /r/rust. Члены основной команды разработки языка есть и там и там, так что часто советы были весьма профессиональными.

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

Владение

Если бы мне надо было описать Rust одним словом, это было бы «владение». Для меня, это то, что отличает Rust от остальных языков. В большинстве языков владение неявно и это приводит к нескольким типам ошибок. Когда в Си функция возвращает указатель, кто ответственен за освобождение памяти? Вы можете ответить на этот вопрос без подглядывания в документацию? И даже если вы знаете ответ, то все равно легко забыть освободить память или освободить ее дважды.

Проблема относится не только к указателям, она касается все ресурсов. Может показаться, что сборка мусора это отличное решение, но она работает только для памяти. Тогда вам нужен другой способ для освобождения ресурсов (вроде файловых дескрипторов) и все проблемы возвращаются. Например, сборщик мусора в C# спасает от ошибок «использования после освобождения» (use after free), но ничего не спасает вас от ошибок «использования после удаления» (use after dispose). Разве ObjectDisposedException намного лучше сегфолта? Из-за явного времени жизни и системы владения в Rust нет этих типов ошибок.

прим. ozkriff: поскольку я с C# знаком мало, то пришлось загуглить про этот ObjectDisposedException. Вот пример кода:

using System;
using System.IO;

public class ObjectDisposedExceptionTest 
{
   public static void Main()
   {     
      MemoryStream ms = new MemoryStream(16);
      ms.Close();
      try 
      {
         ms.ReadByte();
      }
      catch (ObjectDisposedException e) 
      {
         Console.WriteLine("Caught: {0}", e.Message);
      }
   }
}

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

Обновление Luculentus

Сами по себе достоинства явного владения не уникальны для Rust`а. Такой же код можно написать на современном C++, который очень сильно отличается от С++ до-2011. Когда я писал Luculentus, C++11 поддерживался только частично. Я использовал много простых указателей, которые сегодня уже не нужны. Я заменил большинство простых указателей в Luculentus на shared_ptr или unique_ptr, а массивы на векторы. Как следствие, все ручные деструкторы пропали. (Раньше их было шесть). Раньше было 11 операторов удаления, теперь их нет. Все управление памятью стало автоматическим. Это сделало код не только короче, но и снизило вероятность появления ошибок.

Портирование трассировщика путей на Rust улучшило его дизайн. Если ваше управление ресурсами некорректно, то код не скомпилируется. В C++ вы можете, например, взять адрес элемента вектора и, когда вектор уничтожится, указатель на элемент станет некорректным. Но код скомпилируется. Rust не позволяет таких «срезов» и это открыло мне глаза на то, о чем я не думал до этого. Теперь, даже работая с другими языками, я думаю, что если эта конструкция не скомпилировалась бы в Rust`е, то надо поискать путь получше.

Но все же, обновление демонстрирует, что возможно писать относительно безопасный код и на С++. Вы получаете безопасность и автоматическое управление памятью практически без накладных расходов. Единственной проблемой является то, что вы должны очень настойчиво стремиться к этому. Вы можете использовать unique_ptr, но так же можете и простой указатель. Все опасные инструменты «старого» С++ все еще доступны и вы можете смешивать их с новым С++. Конечно, есть определенная ценность в возможности собирать старый код (Бьерн называет это достоинством), но я бы предпочел не смешивать неявно эти две парадигмы и не поддерживать старые ошибочные решения. Требуется некоторое время, что бы разучиться использовать new и delete, но даже тогда старые API останутся с нами на очень долгое время.

Новое начало

Хорошим моментом в Rust является то, что он может начать все практически с чистого листа и учиться на ошибках старых языков. C++11 немного лучше своего предшественника, но он только добавляет новое и обязан поддерживать обратную совместимость. Одна из вещей, на которой это хорошо видно - синтаксис. В Rust, типы идут после имени и возвращаемый функцией тип идет после списка аргументов, что очень разумно. Синтаксис анонимных функций в Rust короток и в нем меньше повторения. Но я так и не могу привыкнуть к египетским скобкам, они до сих пор выглядят как-то не так.

Другим моментов, в котором Rust сделал правильный выбор, является мутабельность. В Rust`е все по-умолчанию неизменяемо, когда как в C++ наоборот. В коде Luculentus 535 раз появляется «const» (на момент написания). В Robigo Luculenta всего 97 «mut». Конечно, в C++ больше дублирования, но это все равно показывает, что неизменяемость по-умолчанию - лучше. Так же, компилятор Rust выдает предупреждение о переменных, которым не нужно быть изменяемыми, это тоже хорошо.

Несмотря на то, что синтаксис является делом вкуса, есть и измеряемые величины. Если я сравню количество непробельных символов в коде, то у С++ будет примерно 109 тысяч символов (не считая файлы, которые я не портировал на Rust), а у Rust - 74 тысячи. Почти на треть меньше.

C++ славится своими информативными и понятными сообщениями об ошибках, когда что-то идет не так в шаблонном коде. Ошибки в Rust`е, в основном, намного более понятны, но некоторые тоже могут напугать:

error: binary operation `/` cannot be applied to type `core::iter::Map<'_,f32,f32,core::iter::Map<'_,&[f32],f32,core::slice::Chunks<'_,f32>>>`

Производительность

Я добавил базовые счетчики производительности в Luculentus и Robigo Luculenta. Они считают количество завершившихся задач трассировки (trace tasks) в секунду. Вот результаты:

Компилятор              платформа           производительность

GCC 4.9.1*              Arch Linux x64      0.35 ± 0.04
GCC 4.9.1               Arch Linux x64      0.33 ± 0.06
rustc 0.12 2014-09-25   Arch Linux x64      0.32 ± 0.01
Clang 3.5.0             Arch Linux x64      0.30 ± 0.05
msvc 110                Windows 7 x64       0.23 ± 0.03
msvc 110*               Windows 7 x64       0.23 ± 0.02
rustc 0.12 2014-09-23   Windows 7 x64       0.23 ± 0.01

Везде выставлены самые высокие уровни оптимизации. Компиляторы со звездочкой использовали PGO (Profile-guided optimization - оптимизация, управляемая профилированием https://ru.wikipedia.org/wiki/Profile-guided_optimization). Единственный вывод, который я могу сделать из этого, что вам, наверное, не стоит использовать Windows для сильно нагружающих процессор приложений.

Во второй статье из этой серии я отметил, что код на Rust`е собирается очень быстро, но тогда было не много кода. Сейчас время сборки вот такое (в секундах):

Компилятор             Время

rustc 0.12 2014-09-26  7.31 ± 0.05
Clang 3.5.0            13.39 ± 0.03
GCC 4.9.1              17.3 ± 0.5
msvc 110               20.4 ± 0.3

Сборка теперь не так быстра, но все равно быстрее С++.

Заключение

Изучать Rust было интересно. Мне понравился язык и портирование привело к нескольким озарениям, которые могут улучшить и оригинальный код. Владение часто неявно в других языках, что увеличивает чувствительность кода к человеческим ошибкам. Rust делает владение явным, убирая возможность допущения подобных ошибок. Все безопасно по умолчанию. Все это сдвигает Rust намного ближе к краю «стабильность» на спектре, чем к краю «быстрая разработка». Я не написал на Rust`е достаточно кода, что бы быть на 100% уверенным, но пока что достоинства Rust`а перевешивали его недостатки. Если бы я выбирал между C++ и Rust`ом для своего следующего проекта, то выбрал бы Rust.

Ну как, это тянет на «нормальное» сравнение? По-моему, в любом случае интересно почитать.

 ,

ozkriff
()

Rust 0.12

Новости — Mozilla
Группа Mozilla

Вышла новая версия инструментов разработки языка программирования Rust. Rust — язык системного программирования, предназначенный для написания быстрых и в то же время безопасных (в том числе и во многопоточной среде) приложений.

В данном релизе упор был сделан на переработку документации языка, приведение к единому виду стандартной библиотеки, улучшение пакетного менеджера Cargo и поддержки Windows.

Обзор обновлений в новой версии:

( читать дальше... )

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

 ,

Slackware-ch
()

Road to Rust 1.0

Форум — Development

Нико опубликовал новый пост в официальном блоге Rust про выпуск стабильной версии:

http://blog.rust-lang.org/2014/09/15/Rust-1.0.html

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

Если коротко, то:

В конце года собираются выпустить бета-версию языка, которая, по прошествии некоторого времени, должна стать версией 1.0. Если во время бета-тестирования будут обнаружены серьезные недостатки, то выпуск 1.0 отложат. Последующие версии 1.* будут обратно совместимы.

Язык очень сильно упростили за последний год, ядром языка стали концепций владения и одалживания (ownership and borrowing). Обращают внимание, что версия 1.0 это не финальный и законченный продукт, а скорее минимальная стабильная основа, на которой можно уже наращивать экосистему. Для последнего очень важным шагом было создание и внедрение в существующие программы и библиотеки пакетного менеджера Cargo, который будет активно улучшаться.

Из комментариев к статье:

1.0 will not be done, complete, useful or production-ready in the sense you'd expect from a modern batteries-included language/platform. It will be «nothing left to take away».

Планируемые к версии 1.0 значительные изменения в самом языке (в статье есть ссылки на подробности по каждому пункту):

  • Типы переменного размера (DST);
  • Упрощение замыканий (Unboxed closures);
  • Ассоциативные типы (Associated types);
  • Конструкция 'where' (Where clauses);
  • Трейты с множественной диспечеризацией (Multidispatch traits);
  • Улучшение деструкторов;
  • Вынос зеленых потоков из стандартной библиотеки;

(Кстати, большая часть даже этих изменений не ломает уже написанный код)

Обсуждения:

 ,

ozkriff
()

Rust - не работают регулярные выражения

Форум — Development

Есть регулярка

^\s*(?P<real>\\-?\d+(?:\\.\d+)?)(?P<imagine>[\\-\\+][i]\d+(?:\\.\d+)?)?
Которая отлично рабоатет, например, здесь: http://regex101.com/r/aC3tM6/1 (двойное экранирование заменено одинарным)
Но совершенно не работает в следующем коде:
let mut input_s = "25.6723+i2234.45";
let num_re = regex!(r"^\s*(?P<real>\\-?\d+(?:\\.\d+)?)(?P<imagine>[\\-\\+][i]\d+(?:\\.\d+)?)?");

println!("Input string: {}", input_s);

match num_re.captures(input_s)
{
	Some(cap) =>
	{
		println!("Capture real: {}", cap.name("real"));
	},
	None => println!("None"),
}
Что я делаю не так? Компилятор последней pre-nightly сборки.
➜ rustc --version
rustc 0.12.0-pre-nightly (2e3858179 2014-09-03 00:51:00 +0000)

 ,

devpony
()