Rust язык. Фичи Rust, которых не хватает в C
Нам очень понравилась статья "Критика языка Rust и почему C/C++ никогда не умрет". Мы предложили автору, что выполним перевод статьи на английский язык, а также опубликовать её в нашем блоге. Он согласился, и мы с удовольствием представляем эту статью на русском и английском языке. Оригинал статьи находится .
Оригинал статьи размещён (текст на русском языке). Статья опубликована в нашем блоге с соглашения автора.
Примечание : Ниже по тексту я исхожу из предположения, что Rust является попыткой сделать быстрый и безопасный язык. В конце концов, ребята из Mozilla делали его, как инструмент разработки браузерного движка . Если же это очередной просто безопасный язык, тогда получаем странное. Самых разных безопасных языков и так уже пруд пруди, каждый найдет себе по вкусу. И если не стоит цели заменить C++, то (1) для чего в языке сделано unsafe подмножество? (2) зачем было удалять из языка легковесные потоки , удобно же? Другими словами, в этом случае происходящее вообще не имеет никакого смысла.
Если вдруг вы почитываете форум linux.org.ru, отмечу, это это не тот список из 10 чисто технических причин не любить Rust , речь о котором шла в этом трэде . Как показало обсуждение в Skype с уважаемым товарищем @sum3rman , есть больше одного мнения касательно того, насколько "техническими" считать эти причины. В общем, фиговый список я составил, но кое-какие пункты из него, наиболее интересные, пожалуй, я все-таки рискну привести. На самом деле, тут и простых, не технических, причин за глаза хватает.
То, что C/C++ в обозримом будущем никуда не денутся, и так любому трезво мыслящему человеку понятно. Никто не станет переписывать почти все десктопные приложения, ядра операционных систем, компиляторы, игровые и браузерные движки, виртуальные машины, базы данных, архиваторы, аудио- и видеокодеки, тонны прочих сишных библиотек, и так далее. Это очень-очень много быстрого, отлаженного, проверенного временем кода. Переписывать его очень-очень дорого, рискованно, и если честно, не лишено смысла только в искаженном сознании только самых упоротых Rust"оманов. Спрос на C/C++ программистов был и будет велик еще очень долго.
Хорошо, а как на счет применения Rust при написании нового кода?
Вспомним, что это уже далеко не первая попытка сделать "более правильный" C/C++. Возьмем хотя бы язык D. Появился в 2001 году, очень хороший язык. Нет ни вакансий, ни нормальных инструментов разработки, ни каких-то особо выдающихся саксесс сторис. Проект OpenMW изначально писали на D, а потом внезапно решили целиком переписать на C++ . Как признаются разработчики, им приходило много писем в стиле "отличный проект, мы были бы рады в него контрибьютить, но не знаем и не хотим знать этот дурацкий D". Википедия сообщает, что помимо D была и масса других попыток в той или иной степени убить C++, например, Vala , Cyclone, Limbo, BitC. Многие ли вообще слышали о таких языках?
Думаю, давно пора извлечь уроки из истории. Ни один здравомыслящий человек не потащит в проект новый язык, пока вы хотя бы не покажете ему нормальные инструменты разработки, не расскажете парочку саксесс сторис и не покажете десяток программистов на этом языке, живущих поблизости. Программисты же, пожалуй, кроме самых молодых, никогда не станут тратить свое время и здоровье на изучение очередного самого правильного языка, пока вы не покажете им нормальные инструменты разработки (не поделки типа Racer), пару десятков тысяч готовых библиотек (не "experimental", "unstable" и так далее), не расскажете парочку саксесс сторис и не покажите десяток открытых вакансий в их городе. Проблема курицы и яйца. Очень редко эту проблему удается успешно решить (условно тут можно привести в пример и Scala), в основном благодаря вложению времени и денег со стороны некоторой крупной компании (Google, Typesafe), по каким-то своим соображениям заинтересованных в популяризации языка.
Как я уже отмечал, одних только не технических причин более, чем достаточно. Однако чисто из любопытства попробуем представить на секунду, что их нет. Тогда нет причин не писать на Rust? Оказывается, это тоже как минимум под очень большим вопросом.
C/C++ критикуют за разное. Критикуют, кстати, очень часто те, кто в продакшене даже издали не видел кода на С++. Коротко и ясно проблему можно описать так: С++ очень быстрый (а также не требовательный к памяти, заряду батареи и тд), но не безопасный в том смысле, что позволяет выходить за границы массивов, по ошибке обращаться к освобожденным кускам памяти и так далее. В свое время эта проблема привела к появлению массы безопасных языков, таких, как Java, C#, Python и других. Но оказалось, что эти языки по сравнению с C++ слишком требовательны к ресурсам и обладают прочими недостатками, вспомним хотя бы неизбежный stop the world при сборке мусора. Поэтому люди бьются над задачей сделать язык такой же быстрый, как C++, но еще и безопасный. Одним из таких языков и является Rust.
Rust действительно безопасный, но, к сожалению, далеко не быстрый. По скорости на момент написания этих строк Rust сравним с Java, Go и Haskell:
Я искренне надеюсь, что со временем его как-то разгонят, но до тех пор в плане компромисса скорости и безопасности он не намного интереснее Scala или Go. До сих пор остается открытым вопрос, можно ли вообще сделать язык быстрым и безопасным, или постоянные проверки на выход за границы массива, безопасные обвязки вокруг биндингов к сишным библиотекам и так далее автоматически делают любой язык в 2 раза медленнее С/C++.
А за счет чего, собственно, Rust безопасен? Если говорить простыми словами, то это язык со встроенным статическим анализатором кода. Действительно очень крутым статическим анализатором, который ловит все типичные для С++ ошибки, притом не только связанные с управлением памятью, но и многопоточностью . Передал по каналу ссылку на изменяемый объект другому потоку, а потом попробовал воспользоваться этой ссылкой сам - все, не скомпилится. Это действительно здорово.
Часто приводится аргумент, что 90% времени выполняется только 10% кода (что, насколько я понимаю, чисто эмпирическое правило - быстро найти строгих исследований на эту тему не удалось). Следовательно, бОльшую часть программы можно написать на безопасном Rust, а 10% "горячего" кода - на его unsafe подмножестве, и медленность текущей реализации Rust на самом деле не представляет собой проблемы. Ок, но тогда получается, что Rust вообще не нужен, потому что я могу написать 90% кода на Go, а 10% на Си. Только искатели серебряных пуль и оторванные от реальности те-еретики будут использовать Rust исключительно из соображений, что 100% программы можно написать как бы на одном языке. Хотя в действительности это два диалекта одного языка, что не так уж сильно отличается от связки Java плюс Си или Go плюс Си.
На самом деле, правило 10:90 - это все равно вранье. По этой логике можно переписать 90% WebKit, 90% VirtualBox или 90% GCC на Java и получить такой же результат. Очевидно, это не так. Даже если дело не в том, что в ряде программ это отношение очень другое, то следите за руками. Допустим, вся программа написана на небезопасном C/C++ и время ее выполнения, условно говоря, равно 0.9*1 (малая часть горячего кода) + 0.1*1 (много холодного кода) = 1. Теперь сравним с программой на безопасном языке со вставками на Си: 0.9*1 + 0.1*2 = 1.1, условно 10% разницы. Это много или мало? Зависит от ваших масштабов. В случае с Google даже несколько процентов могут сэкономить миллионы долларов (см пункт 5 в пейпере, "Utilization"). Или представьте, что со следующим обновлением JVM внезапно начнет требовать на 10% больше ресурсов! Я боюсь даже гадать, сколько нулей будет в цифре, полученной после перевода процентов на американские деньги! 10% - это дофига в задачах, где используются Си и C++.
Мы повторяем "преждевременная оптимизация - корень всех зол", как мантру. Но если следовать ей буквально, то давайте повсюду использовать пузырьковую сортировку вместо quicksort. Мы же не знаем точно, что программа будет именно в этом месте тормозить! Какой смысл оборачивать обыкновенные счетчики каких-тод ействий в акторы или транзакционную память, если можно сразу воспользоваться более эффективным atomic? И вообще, в тривиальных случаях нет смысла принудительно инициализировать все-все-все переменные, делать кучу дополнительных проверок и так далее. Пусть в итоге мы получим не 10% ускорения, а 2-5%. Это ведь тоже совсем неплохо, если потребовало всего лишь пары лишних минут размышлений. И как мы уже выяснили, в задачах, решаемых на С/C++, это может быть большой разницей! Потом, кто сказал, что найти горячее место, переписать код (возможно, очень много кода) и доказать, что он стал действительно быстрее - это проще, чем подумать о производительности заранее?
Если отвлечься от вопроса компромисса скорости и безопасности, то по дизайну самого языка у меня тоже есть вопросы. В частности, касательно пяти типов указателей. С одной стороны, это неплохо, когда программист задумывается о том, где лежат переменные, в стеке или куче, и могут или не могут с ними одновременно работать несколько потоков. Но с другой, представьте, что вы пишите программу, и оказалось, что переменная должна жить не в стеке, а в куче. Вы переписываете все, чтобы использовался Box. Потому вы понимаете, что на самом деле нужен Rc или Arc. Снова переписываете. А потом еще раз переписываете на обычную переменную в стеке. Все это - без нормальной IDE под рукой. И регулярки не помогут. Ну или же просто в стиле "Vec
Из-за этого, в частности, сильно сужается область применения Rust. Никто в здравом уме не станет писать на таком языке веб и серверсайд. Особенно учитывая, что он не дает существенных преимуществ перед теми же языками под JVM. Да и Go с нормальными легковесными потоками (не футурами) для этих задач выглядит куда более привлекательнее. С футурами, чтобы не прострелить себе ногу, нужно еще научиться работать, а вы говорите "безопасный язык". Да, у этих языков свои особенности, взять все тот же stop the world, но эта проблема решаемая, как распиливанием на микросервисы , так и другими приемами . И да, никто не будет транслировать Rust в JavaScript, писать на нем скрипты для раскладки в AWS, или использовать в качестве языка запросов к MongoDB. Под Android тоже вряд ли писать будут, но по другой причине - там сильно больше одной архитектуры, с JVM намного проще. Если вы вдруг думали, что Rust "подходит для всех задач", вынужден вас огорчить.
Ну и до кучи:
- Макросы, как подпорка к излишней многословности, вызванной отсутствием нормальных исключений. Я уже писал о проблемах метапрограммирования , в частности, нормальную IDE для Rust мы вряд ли увидим из-за него. И я не уверен, но похоже, что у макросов в Rust даже неймспейсов нет.
- Люди идиоты, а cargo очень поощряет стягивание пакетов напрямую из git-репозиториев, в обход Crates.io. В итоге велика вероятность получить такой же бардак с пакетами, как и в мире Erlang с его Rabar"ом. К слову, в мире Go, похоже, такая же ситуация.
- Как многие новые языки, Rust идет по пути упрощения. Я в целом понимаю, почему в нем нет нормального наследования и исключений, но сам факт, что кто-то за меня решает такие вещи, оставляет неприятный осадок. C++ не ограничивает программиста в вопросах чем пользоваться, а чем нет.
- Если уж идти по пути упрощения, то выкинуть бы уж все эти расширения языка. А то получается, как в мире Haskell, каждый программист пишет на своем диалекте.
- Смарт поинтеры, если что, далеко не бесплатны и не приводят к предсказуемому времени сборки мусора. Какому-то потоку внезапно выпадает честь освободить очень глубокую структуру данных. Пока он ходит по лабиринту из мертвых ссылок, зависящие от него потоки терпеливо тупят. Та же проблема есть и в Erlang с его маленькими кучками, сам не раз наблюдал. Смарт поинтеры имеют и свои проблемы, ту же фрагменатцию памяти и утечки. Забыл викпоинтер в цеклической структуре, и все. И это в языке, претендующем на безопасность. Если хотите предсказуемого времени GC, либо изучайте поведение вашего приложения под нагрузкой, и предпринимайте меры (вспомним хотя бы те же пулы объектов), если время GC вас не устраивает, либо управляйте памятью вручную.
- Кто-нибудь видел строгое описание семантики Rust? У него хотя бы memory model есть? Тоже мне "безопасный" язык, "доказывающий корректность" программ, который вообще-то может трактовать исходный код десятью разными способами, ха!
- Не могу в очередной раз не напомнить, что проблема почти всегда в людях, а не в технологиях . Если у вас получается плохой код на C++ или Java вдруг тормозит, это не потому что технология плоха, а потому что вы не научились правильно ею пользоваться. Rust вы тоже будете недовольны, но уже по другим причинам. Не проще ли научиться пользоваться более популярными инструментами и начать их любить?
В общем и целом, ближайшие лет 5 я лучше будут инвестировать свое время в изучение C/C++, чем Rust. С++ - это промышленный стандарт . На этом языке успешно решают самые разнообразные задачи уже более 30 лет. А Rust и иже с ним - непонятные игрушки с туманным будущем. Про скорую смерть С++ разговоры идут как минимум с 2000-х, но писать на C/C++ за это время стали не меньше. Скорее наоборот. И мы видим, что язык развивается (C++11, C++14), для него появляются новые инструменты (вспомним хотя бы CLion и Clang), и соответствующих вакансий просто куча.
Программист на C++ всегда без труда найдет себе работу с более чем достойной зарплатой , а при необходимости быстро переучится на Rust. Обратное очень и очень сомнительно. Кстати, язык, если что - далеко не единственный и не решающий фактор при выборе нового места работы. Кроме того, опытный программист на C/C++ без труда вонзается в исходники PostgreSQL или ядра Linux, использует мощные современные инструменты разработки, а также имеет в своем распоряжении множество книг и статей (скажем, по OpenGL).
Берегите свое время и здоровье, их у вас не так много, как кажется!
Rust развивается стабильно, новые возможности и исправления вводятся с каждым релизом раз в 6 недель. Замеченные баги тоже исправляются оперативно в нерегулярных минорных релизах. Иногда такая динамика развития даже может служить препятствием: многие "живые" библиотеки требуют новой версии компилятора, но не всякая компания способна быстро обновлять его на своих проектах.
Инфроструктура вокруг Rust хотя и развивается, все равно еще остается сырой. Многие библиотеки, хотя и работают уже достаточно стабильно, все равно в реальном использовании требуют небольших доработок. Если вы готовы форкать на GitHub такие библиотеки и слегка дорабатывать под свои нужды, то я думаю у вас больше никаких особых проблем с использованием Rust в боевых проектах возникнуть не должно.
Какого-то единого сборника лучших практик использования Rust, насколько я знаю, пока нет. Много полезных советов есть в официальной документации (в так называемых Книгах), а также разбросано по разным отдельным статьям. Однако, существуют списки полезных статей, которые помогут найти среди них нужную. Например эти:
https://github.com/ctjhoa/rust-learning
https://github.com/brson/rust-anthology/blob/maste...
В новых проектах Rust используется, и пока тенденция идет на расширение. Вот на этой странице вы можете посмотреть, какие компании используют Rust сейчас и для чего: https://www.rust-lang.org/en-US/friends.html
Итак, если вы планируете использовать Rust в производстве, готовьтесь вот к чему:
- Довольно высокий порог входа в язык. Тут нет особой сложности, просто потребуется практика на языке и поначалу время на следование советам компилятора по устранению постоянно возникающих ошибок компиляции.
- Достаточно частые обновления компилятора по добавлению новых возможностей в язык. Это может приводить к тому, что нужная вам библиотека будет требовать свежую версию компилятора.
- Сыроватые библиотки. Вероятно, вам придется их слегка дорабатывать под себя.
- Rust упрощает сложное, но усложняет простое. Для совсем простых проектов, не требующих высокой производительности и серьезных доработок в будущем, возможно, Rust будет не лучшим выбором.
- Высокую производительность программ, автоматическое управление памятью без сборщика мусора.
- Высокую надежность и защищенность программ, устранение большого количества потенциальных проблем на этапе компиляции.
- Достаточно легкий и безопасный процесс рефакторинга и доработки программ, благодаря развитой системе типов.
- Развитую систему управления зависимостями проекта.
- Действительно хороший универсальный инструмент: Rust подойдет и для прототипирования, и для разработки, причем для любого типа программ (утилиты, настольные приложения, веб-приложения, мобильные приложения, встраиваемые системы). Хорошая поддержка пока еще есть не для всего, но на перспективу - это большой плюс.
Rust
- новый экспериментальный язык программирования, разрабатываемый Mozilla. Язык компилируемый и мультипарадигмальный, позиционируется как альтернатива С/С++, что уже само по себе интересно, так как даже претендентов на конкуренцию не так уж и много. Можно вспомнить D Вальтера Брайта или Go от Google.
В Rust поддерживаются функицональное, параллельное, процедурное и объектно-ориентированное программирование, т.е. почти весь спектр реально используемых в прикладном программировании парадигм.
Я не ставлю целью перевести документацию (к тому же она весьма скудная и постоянно изменяется, т.к. официального релиза языка еще не было), вместо этого хочется осветить наиболее интересные фичи языка. Информация собрана как из официальной документации, так и из крайне немногочисленных упоминаний языка на просторах Интернета.
Первое впечатление
Синтаксис языка строится в традиционном си-подобном стиле (что не может не радовать, так как это уже стандарт де-факто). Естественно, всем известные ошибки дизайна С/С++ учтены.Традиционный Hello World выглядит так:
use std; fn main(args: ) { std::io::println("hello world from " + args + "!"); }
Пример чуть посложнее - функция расчета факториала:
Fn fac(n: int) -> int { let result = 1, i = 1; while i <= n { result *= i; i += 1; } ret result; }
Как видно из примера, функции объявляются в «функциональном» стиле (такой стиль имеет некоторые преимущества перед традиционным «int fac(int n)»). Видим автоматический вывод типов (ключевое слово let), отсутствие круглых скобок у аргумента while (аналогично Go). Еще сразу бросается в глаза компактность ключевых слов. Создатели Rust дейтсвительно целенаправленно сделали все ключевые слова как можно более короткими, и, скажу честно, мне это нравится.
Мелкие, но интересные синтаксические особенности
- В числовые константы можно вставлять подчеркивания. Удобная штука, сейчас эту возможность добавляют во многие новые языки.
0xffff_ffff_ffff_ffff_ffff_ffff - Двоичные константы. Конечно, настоящий программист должен преобразовывать bin в hex в уме, но ведь так удобнее! 0b1111_1111_1001_0000
- Тела любых операторов (даже состоящие из единственного выражения) должны быть обязательно заключены в фигурные скобки. К примеру, в Си можно было написать if(x>0) foo(); , в Rust нужно обязательно поставить фигурнные скобки вокруг foo()
- Зато аргументы операторов if, while и подобных не нужно заключать в кругные скобки
- во многих случаях блоки кода могут рассматриваться как выражения. В частности, возможно например такое:
let x = if the_stars_align() { 4 } else if something_else() { 3 } else { 0 }; - синтаксис объявления функций - сначала ключевое слово fn, затем список аргументов, тип аргумента указывается после имени, затем, если функция возвращает значение - стрелочка "->" и тип возвращаемого значения
- аналогичным образом объявляются переменные: ключевое слово let, имя переменной, после переменной можно через двоеточие уточнить тип, и затем - присвоить начальное значение.
let count: int = 5; - по умолчанию все переменные неизменяемые; для объявления изменяемых переменных используется ключевое слово mutable.
- имена базовых типов - самые компактные из всех, которые мне встречались: i8, i16, i32, i64, u8, u16, u32, u64,f32, f64
- как уже было сказано выше, поддерживается автоматический вывод типов
Ключевое слово fail завершает текущий процесс
Ключевое слово log выводит любое выражение языка в лог (например, в stderr)
Ключевое слово assert проверяет выражение, и если оно ложно, завершает текущий процесс
Ключевое слово note позволяет вывести дополнительную инфорацию в случае аварийного завершения процесса.
Типы данных
Rust, подобно Go, поддерживает структурную типизацию (хотя, по утверждению авторов, языки развивались независимо, так что это влияние их общих предшественников - Alef, Limbo и т.д.). Что такое структурная типизация? Например, у вас в каком-то файле объявлена структура (или, в терминологии Rust, «запись»)type point = {x: float, y: float};
Вы можете объявить кучу переменных и функций с типами аргументов «point». Затем, где-нибудь в другом месте, вы можете объявить какую-нибудь другую структуру, например
type MySuperPoint = {x: float, y: float};
и переменные этого типа будут полностью совместимы с переменными типа point.
В противоположность этому, номинативная типизация, принятая в С, С++,C# и Java таких конструкций не допускает. При номинативной типизации каждая структура - это уникальный тип, по умолчанию несовместимый с другими типами.
Структуры в Rust называются «записи» (record). Также имеются кортежи - это те же записи, но с безымянными полями. Элементы кортежа, в отличие от элементов записи, не могут быть изменяемыми.
Имеются вектора - в чем-то подобные обычным массивам, а в чем-то - типу std::vector из stl. При инициализации списком используются квадратные скобки, а не фигурные как в С/С++
Let myvec = ;
Вектор, тем ни менее - динамическая структура данных, в частности, вектора поддерживают конкатенацию.
Let v: mutable = ; v += ;
Есть шаблоны. Их синтаксис вполне логичен, без нагромождений «template» из С++. Поддерживаются шаблоны функций и типов данных.
Fn for_rev
Язык поддерживает так называемые теги . Это не что иное, как union из Си, с дополнительным полем - кодом используемого варианта (то есть нечто общее между объединением и перечислением). Или, с точки зрения теории - алгебраический тип данных.
Tag shape { circle(point, float); rectangle(point, point); }
В простейшем случае тег идентичен перечислению:
Tag animal {
dog;
cat;
}
let a: animal = dog;
a = cat;
В более сложных случаях каждый элемент «перечисления» - самостоятельная структура, имеющая свой «конструктор».
Еще интересный пример - рекурсивная структура, с помощью которой задается объект типа «список»:
tag list
Теги могут участвовать в выражениях сопоставления с образцом, которые могут быть достаточно сложными.
alt x {
cons(a, @cons(b, _)) {
process_pair(a,b);
}
cons(10, _) {
process_ten();
}
_ {
fail;
}
}
Сопоставление с образцом (pattern matching)
Для начала можно рассматривать паттерн матчинг как улучшенный switch. Используется ключевое слово alt, после которого следует анализируемое выражение, а затем в теле оператора - паттерны и действия в случае совпадения с паттернами.alt my_number { 0 { std::io::println("zero"); } 1 | 2 { std::io::println("one or two"); } 3 to 10 { std::io::println("three to ten"); } _ { std::io::println("something else"); } }
В качестве «паттеронов» можно использовать не только константы (как в Си), но и более сложные выражения - переменные, кортежи, диапазоны, типы, символы-заполнители (placeholders, "_"). Можно прописывать дополнительные условия с помощью оператора when, следующего сразу за паттерном. Существует специальный вариант оператора для матчинга типов. Такое возможно, поскольку в языке присутствует универсальный вариантный тип any , объекты которого могут содержать значения любого типа.
Указатели.
Кроме обычных «сишных» указателей, в Rust поддерживаются специальные «умные» указатели со встроенным подсчетом ссылок - разделяемые (Shared boxes) и уникальные (Unique boxes). Они в чем-то подобны shared_ptr и unique_ptr из С++. Они имеют свой синтаксис: @ для разделяемых и ~ для уникальных. Для уникальных указателей вместо копирования существует специальная операция - перемещение:
let x = ~10;
let y <- x;
после такого перемещения указатель x деинициализируется.
Замыкания, частичное применение, итераторы
С этого места начинается функциональное программирование. В Rust полностью поддерживается концепция функций высшего порядка - то есть функций, которые могут принимать в качестве своих аргументов и возвращать другие функции.1. Ключевое слово lambda используется для объявления вложенной функции или функционального типа данных.
Fn make_plus_function(x: int) -> lambda(int) -> int { lambda(y: int) -> int { x + y } } let plus_two = make_plus_function(2); assert plus_two(3) == 5;
В этом примере мы имеем функцию make_plus_function, принимающую один аргумент «x» типа int и возвращающую функцию типа «int->int» (здесь lambda - ключевое слово). В теле функции описывается эта самая фунция. Немного сбивает с толку отсутствие оператора «return», впрочем, для ФП это обычное дело.
2. Ключевое слово block
используется для объявления функционального типа - аргумента функции, в качестве которого можно подставить нечто, похожее на блок обычного кода.
fn map_int(f: block(int) -> int, vec: ) -> {
let result = ;
for i in vec { result += ; }
ret result;
}
map_int({|x| x + 1 }, );
Здесь мы имеем функцию, на вход которой подается блок - по сути лямбда-функция типа «int->int», и вектор типа int (о синтаксисе векторов далее). Сам «блок» в вызывающем коде записыавется с помощью несколько необычного синтаксиса {|x| x + 1 }. Лично мне больше нравятся лямбды в C#, символ | упорно воспринимается как битовое ИЛИ (которое, кстати, в Rust также есть, как и все старые добные сишные операции).
3. Частичное применение - это создание функции на основе другой функции с большим количеством аргументов путем указания значений некоторых аргументов этой другой функции. Для этого используется ключевое слово bind и символ-заполнитель "_":
Let daynum = bind std::vec::position(_, ["mo", "tu", "we", "do", "fr", "sa", "su"])
Чтобы было понятнее, скажу сразу, что такое можно сделать на обычном Си путем создания простейшей обертки, как-то так:
const char* daynum (int i) { const char *s ={"mo", "tu", "we", "do", "fr", "sa", "su"}; return s[i]; }
Но частичное применение - это функциональный стиль, а не процедурный (кстати, из приведенного примера неясно, как сделать частичное применение, чтобы получить функцию без аргументов)
Еще пример: объявляется функция add с двумя аргументами int, возвращающая int. Далее объявляется функциональный тип single_param_fn, имеющий один аргумент int и возвращающий int. С помощью bind объявляются два функциональных объекта add4 и add5, построенные на основе функции add, у которой частично заданы аргументы.
Fn add(x: int, y: int) -> int { ret x + y; } type single_param_fn = fn(int) -> int; let add4: single_param_fn = bind add(4, _); let add5: single_param_fn = bind add(_, 5);
Функциональные объекты можно вызывать также, как и обычные функции.
assert (add(4,5) == add4(5));
assert (add(4,5) == add5(4));
4. Чистые функции и предикаты
Чистые (pure) функции - это функции, не имеющие побочных эффектов (в том числе не вызывающие никаких других функций, кроме чистых). Такие функции выдяляются ключевым словом pure.
pure fn lt_42(x: int) -> bool {
ret (x < 42);
}
Предикаты - это чистые (pure) функции, возвращающие тип bool. Такие функции могут использоваться в системе typestate (см. дальше), то есть вызываться на этапе компиляции для различных статических проверок.
Синтаксические макросы
Планируемая фича, но очень полезная. В Rust она пока на стадии начальной разработки.
std::io::println(#fmt("%s is %d", "the answer", 42));
Выражение, аналогичное сишному printf, но выполняющееся во время компиляции (соответственно, все ошибки аргументов выявляются на стадии компиляции). К сожалению, материалов по синтаксическим макросам крайне мало, да и сами они находятся в стадии разработки, но есть надежда что получится что-то типа макросов Nemerle .
Кстати, в отличие от того же Nemerle, решение выделить макросы синтаксически с помощью символа # считаю очень грамотным: макрос - это сущность, очень сильно отличающаяся от функции, и я считаю важным с первого взгляда видеть, где в коде вызываются функции, а где - макросы.
Атрибуты
Концепция, похожая на атрибуты C# (и даже со схожим синтаксисом). За это разработчикам отдельное спасибо. Как и следовало ожидать, атрибуты добавляют метаинформацию к той сущности, которую они аннотируют,# fn register_win_service() { /* ... */ }
Придуман еще один вариант синтаксиса атрибутов - та же строка, но с точкой с запятой в конце, аннотирует текущий контекст. То есть то, что соответствует ближайшим фигурным скобкам, охватывающим такой атрибут.
fn register_win_service() { #; /* ... */ }
Параллельные вычисления
Пожалуй, одна из наиблее интересных частей языка. При этом в tutorial на данный момент не описана вообще:)Программа на Rust состоит из «дерева задач». Каждая задача имеет функцию входа, собственный стек, средства взаимодействия с другими задачами - каналы для исходящей информации и порты для входящей, и владеет некоторой частью объектов в динамической куче.
Множество задач Rust могут существовать в рамках одного процесса операционной системы. Задачи Rust «легковесные»: каждая задача потребляет меньше памяти чем процесс ОС, и переключение между ними осуществляется быстрее чем переключение между процессами ОС (тут, вероятно, имеются в виду все-же «потоки»).
Задача состоит как минимум из одной функции без аргументов. Запуск задачи осуществляется с помощью функции spawn. Каждая задача может иметь каналы, с помощью которых она передает инфорацию другим задачам. Канал - это специальный шаблонный тип chan, параметризируемый типом данных канала. Например, chan - канал для передачи беззнаковых байтов.
Для передачи в канал используется функция send, первым аргументом которой является канал, а вторым - значение для передачи. Фактически эта функция помещает значение во внутренний буфер канала.
Для приема данных используются порты. Порт - это шаблонный тип port, параметризируемый типом данных порта: port - порт для приема беззнаковых байтов.
Для чтения из портов используется функция recv, аргументом которой является порт, а возвращаемым значением - данные из порта. Чтение блокирует задачу, т.е. если порт пуст, задача переходит в состояние ожидания до тех пор, пока другая задача не отправит на связанный с портом канал данные.
Связывание каналов с портами происходит очень просто - путем инициализации канала портом с помощью ключевого слова chan:
let reqport = port();
let reqchan = chan(reqport);
Несколько каналов могут быть подключены к одному порту, но не наоборот - один канал не может быть подключен одновременно к нескольким портам.
Typestate
Общепринятого перевода на русский понятия «typestate» я так и не нашел, поэтому буду называть это «состояния типов». Суть этой фичи в том, что кроме обычного контроля типов, принятого в статической типизации, возможны дополнительные контекстные проверки на этапе компиляции.В том или ином виде состояния типов знакомы всем программистам - по сообщениям компилятора «переменная используется без инициализации». Компилятор определяет места, где переменная, в которую ни разу не было записи, используется для чтения, и выдает предупреждение. В более общем виде эта идея выглядит так: у каждого объекта есть набор состояний, которые он может принимать. В каждом состоянии для этого объекта определены допустимые и недопустимые операции. И компилятор может выполнять проверки - допустима ли конкретная операция над объектом в том или ином месте программы. Важно, что эти проверки выполняются на этапе компиляции.
Например, если у нас есть объект типа «файл», то у него может быть состояние «закрыт» и «открыт». И операция чтения из файла недопустима, если файл закрыт. В современных языках обычно функция чтения или бросает исключение, или возвращает код ошибки. Система состояний типов могла бы выявить такую ошибку на этапе компиляции - подобно тому, как компилятор определяет, что операция чтения переменной происходит до любой возможной операции записи, он мог бы определить, что метод «Read», допустимый в состоянии «файл открыт», вызывается до метода «Open», переводящего объект в это состояние.
В Rust существует понятие «предикаты» - специальные функции, не имеющие побочных эффектов и возвращающие тип bool. Такие функции могут использоваться компилятором для вызова на этапе компиляции с целью статических проверок тех или иных условий.
Ограничения (constraints) - это специальные проверки, которые могут выполняться на этапе компиляции. Для этого используется ключевое слово check.
pure fn is_less_than(int a, int b) -< bool {
ret a < b;
}
fn test() {
let x: int = 10;
let y: int = 20;
check is_less_than(x,y);
}
Предикаты могут «навешиваться» на входные параметры функций таким вот способом:
fn test(int x, int y) : is_less_than(x,y) { ... }
Информации по typestate крайне мало, так что многие моменты пока непонятны, но концепция в любом случае интересная.
На этом все. Вполне возможно, что я все-же пропустил какие-то интересные моменты, но статья и так раздулась. При желании можно уже сейчас собрать компилятор Rust и попробовать поиграться с различными примерами. Информация по сборке приведена на
На сегодняшний день синтаксис Rust поддерживается в vim и emacs с помощью поставляемых вместе с компилятором синтаксических файлов.
Имеются также синтаксические пакеты для популярного проприетарного редактора Sublime Text 2 и свободного редактора Kate. Поддержки Rust в IDE пока нет. Поддержка отладчиков, судя по всему, тоже отсутствует.
Вместе с компилятором rustc поставляются следующие утилиты:
> rustdoc
- утилита для автоматической генерации документации из исходного кода наподобие Doxygen;
> rustpkg
- менеджер пакетов, позволяющий легко устанавливать дополнительные пакеты и библиотеки;
> rusti
- так называемая REPL-утилита (read-eval-print-loop). По сути это тестовый интерпретатор, который принимает выражение на Rust из командной строки, компилирует его во внутреннее представление LLVM, выполняет и выводит результат;
> rust
- универсальная утилита, запускающая другие утилиты или компилятор в зависимости от параметров. У меня она так и не заработала.
Вся доступная документация по языку собрана на официальном сайте www.rust-lang.org. Имеется подробное руководство (http://static.rust-lang.org/doc/tutorial.html) - исчерпывающая формальная документация по всем нюансам синтаксиса, модели памяти, системе времени выполнения и т.п., а также документация по встроенной библиотеке core и стандартной библиотеке std. Вся документация англоязычная. На русском языке актуальных материалов нет, а пара имеющихся обзорных статей уже успели сильно устареть.
Идеология и синтаксис
Rust относится к Си-подобным языкам, использующим фигурные скобки для выделения блоков кода. Язык является «мультипарадигменным», т.е. позволяет писать код в императивно-процедурной, объектно-ориентированной, конкурентной или функциональной манере. Rust компилируется в нативный бинарный код на любой поддерживаемой платформе (использует LLVM в качестве бекэнда). В теории код на Rust не должен уступать в скорости коду на C/C++. Rust позиционируется как системный язык, однако в нем нет встроенной поддержи блоков кода на ассемблере как в «истинных» системных языках С, С++ или D.
Модель памяти Rust изначально не допускает появления нулевых или «висячих» указателей и переполнений буфера. Имеется опциональный сборщик мусора, работающий только в пределах одной нити кода. У языка есть встроенная поддержка легковесной многозадачности и коммуникаций между нитями с помощью обмена сообщениями. Разделяемой памяти (shared memory) в Rust не существует в принципе. Все переменные подразделяются на стековые, переменные кучи для данного потока, и переменные так называемой «обменной» кучи, которые могут читаться всеми потоками, но не могут ими изменяться. Это автоматически исключает «заклинивание» (deadlock), которое считается бичом многопоточного программирования. ABI языка совместим с Си, поэтому программы на Rust могут компоноваться с библиотеками, написанными на Си без дополнительных оберток. Для нужд низкоуровневого системного программирования и для обеспечения совместимости с Си в языке есть особый «небезопасный» режим без проверки корректности указателей. По своей идеологии Rust ближе всего к языку Go. Так же, как и в Go, основной акцент сделан на простоте многопоточного программирования и скорости разработки масштабных приложений, а синтаксис местами так же непривычен и в чем-то удивителен. В то же время Rust не настолько минималистичен, как Go, и претендует на роль системного языка.
Синтаксис Rust большей частью заимствован из С и С++ с примесью идей из языков Go, C#, Haskell, Python и Ruby. Не буду исчерпывающе описывать синтаксис языка, а остановлюсь только на наиболее интересных концепциях.
Я новичок в языке Rust, но он быстро становится моим любимым языком программирования. Хотя написание небольших проектов на Rust обычно менее эргономично и занимает больше времени(по крайней мере, со мной за рулём), это бросает вызов тому, как я думаю о дизайне программы. Мои бои с компилятором становятся менее частыми, после того как я узнаю что-то новое.
Сообщество Rust в последнее время сконцентрировало много своих усилий на асинхронном вводе/выводе, реализованном в виде библиотеки Tokio . И это замечательно.
Многим из участников сообщества, тем, которые не работали с веб-серверами и связанными с этим вещами, не ясно, чего же мы хотим добиться. Когда эти вещи обсуждались во времена версии 1.0, я тоже имел смутное представление об этом, никогда прежде не работав с этим раньше.
- Что это такое - Async I/O ?
- Что такое корутины(coroutines )?
- Что такое легковесные потоки(lightweight threads )?
- Как они сочетаются между собой?
Что такое футуры?(futures )?
Я покажу вам, как написать небольшую программу, которая скачивает ленту (feed ) в формате JSON, парсит и выводит список заметок на консоль в форматированном виде.
У нас все вылилось в очень лаконичный код. Как? Смотрите под катом.
Ключевое слово unsafe является неотъемлемой частью дизайна языка Rust. Для тех кто не знаком с ним: unsafe - это ключевое слово, которое, говоря простым языком, является способом обойти проверку типов(type checking ) Rust’а.
Существование ключевого слова unsafe для многих поначалу является неожиданностью. В самом деле, разве то, что программы не« падают» от ошибок при работе с памятью, не является особенностью Rust? Если это так, то почему имеется лёгкий способ обойти систему типов? Это может показаться дефектом дизайна языка.
Все же, по моему мнению, unsafe не является недостатком. На самом деле он является важной частью языка. unsafe выполняет роль некоторого выходного клапана - это значит то, что мы можем использовать систему типов в простых случаях, однако позволяя использовать всевозможные хитрые приёмы, которые вы хотите использовать в вашем коде. Мы только требуем, чтобы вы скрывали эти ваши приёмы( unsafe код) за безопасными внешними абстракциями.
Данная заметка представляет ключевое слово unsafe и идею ограниченной« небезопасности». Фактически это предвестник заметки , которую я надеюсь написать чуть позже. Она обсуждает модель памяти Rust, которая указывает, что можно, а что нельзя делать в unsafe коде.
Будучи новичком в Rust, я запутывался в различных способах представления строк. В книге о языке Rust есть глава « References and Borrowing» , в которой используется три различных типа строковых переменных в примерах: String , &String и &str .
Начнём с разницы между str и String: String - это расширяемая, выделяемая на куче структура данных, тогда как str - это неизменяемая строка фиксированной длины, где-то в памяти.
Многие программисты уже умеют программировать на объектно-ориентированных языках. Rust не является классическим объектно-ориентированным языком, но основные инструменты ООП можно применять и в нём.
В этой статье мы рассмотрим, как программировать на Rust в ООП-стиле. Мы будем делать это на примере: построим иерархию классов в учебной задаче.
Наша задача - это работа с геометрическими фигурами. Мы будем выводить их на экран в текстовом виде и вычислять их площадь. Наш набор фигур - прямоугольник, квадрат, эллипс, круг.
Rust - элегантный язык, который несколько отличается от многих других популярных языков. Например, вместо использования классов и наследования, Rust предлагает собственную систему типов на основе типажей. Однако я считаю, что многим программистам, начинающим своё знакомство с Rust(как и я), неизвестны общепринятые шаблоны проектирования.
В этой статье, я хочу обсудить шаблон проектирования новый тип (newtype), а также типажи From и Into , которые помогают в преобразовании типов.
Последнее время я много размышлял о шаблонах проектирования и приёмах, которые мы используем в программировании. Это и в самом деле прекрасно - начать исследовать проект и видеть знакомые шаблоны и стили, которые ты уже не раз встречал. Это облегчает понимание проекта и даёт возможность ускорить работу.
Иногда ты работаешь над новым проектом и понимаешь, что тебе нужно сделать что-то также, как ты делал это в прошлом проекте. Это может быть не часть функционала или библиотека, это может быть то, что нельзя обернуть в изящный макрос или маленький контейнер. Это может быть просто шаблон проектирования или структурная концепция, которые хорошо решают проблему.
Один интересный шаблон, часто применяемый к таким проблемам -« Конечный автомат». Предлагаю потратить немного времени, чтобы понять, что именно имеется ввиду под этим словосочетанием, и почему же это так интересно.
Ниже представлено графическое описание перемещения, копирования и заимствования в языке программирования Rust . В основном, эти понятия специфичны только для Rust и часто являются камнем преткновения для новичков.
Чтобы избежать путаницы, я попытался свести текст к минимуму. Данная заметка не является заменой различных учебных руководств, и лишь сделана для тех, кто считает, что визуально информация воспринимается легче. Если вы только начали изучать Rust и считаете данные графики полезными, то я бы порекомендовал вам отмечать свой код похожими схемами для лучшего закрепления понятий.
Реализация арифметики натуральных чисел с помощью чисел Пеано - популярная задача в обучение программированию. Мне было интересно, можно ли реализовать их на Rust.
Таким образом моя задача: записать и сложить натуральные числа с проверкой на уровне типов.
Если верить википедии« Аксио́мы Пеа́но - одна из систем аксиом для натуральных чисел, введённая в XIX веке итальянским математиком Джузеппе Пеано.»
Нас интересуют две из них - с помощью которых можно ввести и использовать натуральные числа:
- 1 является натуральным числом
- Число, следующее за натуральным, тоже является натуральным.
Дословно запишем на rust с помощью:
| 1 2 3 4 | enum Nat { Zero , Succ (Nat ) } |
Nat - это либо ноль, либо следующее натуральное число.
Замечание : проект futures-rs был реорганизован и многие вещи были переименованы. Где возможно, ссылки были обновлены.
Начинаем работу с futures
Этот документ поможет вам изучить контейнер для языка программирования Rust - futures , который обеспечивает реализацию futures и потоков с нулевой стоимостью. Futures доступны во многих других языках программирования, таких как C++ , Java , и Scala , и контейнер futures черпает вдохновение из библиотек этих языков. Однако он отличается эргономичностью, а также придерживается философии абстракций с нулевой стоимостью, присущей Rust, а именно: для создания и композиции futures не требуется выделений памяти, а для Task , управляющего ими, нужна только одна аллокация. Futures должны стать основой асинхронного компонуемого высокопроизводительного ввода/вывода в Rust, и ранние замеры производительности показывают, что простой HTTP сервер, построенный на futures, действительно быстр.
Эта документация разделена на несколько разделов:
- « Здравствуй, мир!»;
- типаж future;
- типаж Stream ;
- конкретные futures и поток( Stream);
- возвращение futures;
- Task и future;
- локальные данные задачи.
Замечание : проект futures-rs был реорганизован и многие вещи были переименованы. Где возможно, ссылки были обновлены.
Одним из основных пробелов в экосистеме Rust был быстрый и эффективный асинхронный ввод/вывод . У нас есть прочный фундамент из библиотеки mio , но она очень низкоуровневая: приходится вручную создавать конечные автоматы и жонглировать обратными вызовами.
Нам бы хотелось чего-нибудь более высокоуровневого, с лучшей эргономикой, но чтобы оно обладало хорошей компонуемостью , поддерживая экосистему асинхронных абстракций, работающих вместе. Звучит очень знакомо: ту же цель преследовало внедрение futures (или promises) во многие языки , поддерживающие синтаксический сахар в виде async/await на вершине.
Примитивные целочисленные типы, поддерживаемые процессорами, являются ограниченным приближением к бесконечному набору целых чисел, которыми мы привыкли оперировать в реальной жизни. Это ограниченное представление не всегда совпадает с« реальными» числами, например 255_u8 + 1 == 0 . Зачастую программист забывает об этой разнице, что легко может приводить к багам.
Rust - это язык программирования, целью которого является защита от багов, он фокусируется на предотвращении наиболее коварных из них - ошибок работы с памятью, но также старается помочь программисту избежать остальных проблем: , игнорирования ошибок и, как мы увидим, переполнения целых чисел .
Немного об Iron
Iron - это высокоуровневый веб-фреймворк, написанный на языке программирования Rust и построенный на базе другой небезызвестной библиотеки hyper. Iron разработан таким образом, чтобы пользоваться всеми преимуществами, которые нам предоставляет Rust. Iron старается избегать блокирующих операций в своём ядре.
Философия
Iron построен на принципе расширяемости настолько, насколько это возможно. Он вводит понятия для расширения собственного функционала:
- « промежуточные» типажи - используются для реализации сквозного функционала в обработке запросов;
- модификаторы - используются для изменения запросов и ответов наиболее эргономичным способом.
С базовой частью модификаторов и промежуточных типажей вы познакомитесь в ходе статьи.
Создание проекта
Для начала создадим проект с помощью Cargo, используя команду:
Скомпилировав получим соответствующий исполняемый файл:
| 1 2 3 | $ rustc hello.rs $ du -h hello 632K hello |
632 килобайт для простого принта?! Rust позиционируется как системный язык, который имеет потенциал для замены C/C++, верно? Так почему бы не проверить аналогичную программу на ближайшем конкуренте?
В нашей среде широко распространена мысль о том, что одним из преимуществ сборщика мусора является простота разработки высоко-производительных lock-free структур данных. Ручное управление памятью в них сделать не просто, а GC с лёгкостью решает эту проблему.
Этот пост покажет, что, используя Rust, можно построить API управления памятью для конкурентных структур данных, которое:
- Сделает возможным реализацию lock-free структуры данных, как это делает GC;
- Создаст статическую защиту от неправильного использования схемы управления памятью;
- Будет иметь сравнимые с GC накладные расходы(и более предсказуемые).
В тестах, которые я покажу ниже, Rust легко превосходит реализации lock-free очередей в Java, а саму реализацию на Rust легко написать.
Я реализовал схему управления памятью, основанную на эпохах(«epoch-based memory reclamation») в новой библиотеке Crossbeam, которая на сегодняшний день готова к использованию с вашими структурами данных. В этом посте я расскажу о lock-free структурах данных, алгоритме эпох и внутреннем API Rust.
Ошибки доступа к памяти и утечки памяти представляют собой две категории ошибок, которые привлекают больше всего внимания, так что на предотвращение или хотя бы уменьшение их количества направлено много усилий. Хотя их название и предполагает схожесть, однако они в некотором роде диаметрально противоположны и решение одной из проблем не избавляет нас от второй. Широкое распространение управляемых языков подтверждает эту идею: они предотвращают некоторые ошибки доступа к памяти, беря на себя работу по освобождению памяти.
Проще говоря: нарушение доступа к памяти - это какие-то действия с некорректными данными, а утечка памяти - это отсутствие определённых действий с корректными данными . В табличной форме:
У меня есть несколько мыслей об изучении языков программирования.
Во-первых, мы подходим к этому неправильно. Я уверен, что вы испытывали такие же ощущения. Вы пытаетесь изучить новый язык и не совсем понимаете, как в нём всё устроено. Почему в одном месте используется один синтаксис, а в другом другой? Все эти странности раздражают, и в итоге мы возвращаемся к привычному языку.
Я считаю, что наше восприятие языков играет с нами злую шутку. Вспомните, как вы последний раз обсуждали новый язык. Кто-то упомянул о нём, а кто-то другой поинтересовался его скоростью, синтаксисом или имеющимся веб-фреймворком.
Это очень похоже на обсуждение автомобилей. Слышали о новом УАЗ Рыбак? Насколько он быстр? Смогу ли я проехать на нём через озеро?
Когда мы похожим образом говорим о языках, то подразумеваем, что они взаимозаменяемы. Как машины. Если я знаю, как управлять Ладой Саранск, значит смогу вести и УАЗ Рыбак без каких-либо проблем. Разница только в скорости и приборной панели, не так ли?
Но представьте, как будет выглядеть PHP-автомобиль. А теперь вообразите, насколько будет отличаться автомобиль Lisp. Пересесть с одного на другой потребует гораздо большего, чем усвоить, какая кнопка управляет отоплением.
Примечание: Эта статья предполагает, что читатель знаком с Rust FFI (перевод), порядком байтов (endianess) и ioctl .
При создании биндингов к коду на С мы неизбежно столкнёмся со структурой, которая содержит в себе объединение. В Rust отсутствует встроенная поддержка объединений, так что нам придётся выработать стратегию самостоятельно. В С объединение - это тип, который хранит разные типы данных в одной области памяти. Существует много причин, по которым можно отдать предпочтение объединению, такие как: преобразование между бинарными представлениями целых чисел и чисел с плавающей точкой, реализация псевдо-полиморфизма и прямой доступ к битам. Я сфокусируюсь на псевдо-полиморфизме.