Итак, хотим представить вашему вниманию недавнего именинника (15 мая 2016 года ему исполнился год) — Rust. Это универсальный язык программирования, разрабатываемый компанией Mozilla, три основных принципа которого: скорость, безопасность и эргономика. Сами создатели нескромно считают его одним наиболее вероятных наследников C/C++. Согласно опросу портала StackOverflow , именно Rust сегодня наиболее любимый разработчиками язык. Итак, давайте подробнее разбираться в том, что же он из себя представляет.

Rust для новичка

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

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

Как изучать

Почти всё необходимое вы можете найти на официальном сайте . Кроме того, сообщество последователей Rust весьма обширно и доброжелательно, поэтому за советом всегда можно обратиться в IRC (есть русский раздел) и официальный форум. Кроме того, понемногу стали появляться книги, в том числе электронные . Пока трудно оценить их качество, но факт такой имеется.

Для тех, кто прошёл начальную стадию знакомства, на GiHub можно найти уйму полезного материала, в том числе RFC и коммиты . Кроме того, вы можете посетить лично или хотя бы посмотреть интернет-трансляцию одной из конференций по Rust, намеченных на вторую половину года. Вот календарь:

• 9-10 сентября конференция RustConf в Портленде, США;
• 17 сентября конференция европейского сообществ RustFest в Берлине, Германия;
• 27 октября конференция Rust Belt Rust в Питтсбурге, США;

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

Особенности

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

Плюсы:

• Безопасная работа с памятью;
• Высокое быстродействие;
• Алгебраический тип данных;
• Предсказуемость компиляции;

Минусы:

• Некоторая избыточность кода;
• Высокая интенсивность развития языка и, как следствие, отсутствие хорошей актуальной литературы для изучения;
• Необходимость чётко и однозначно прописывать параметры для компиляции.

На самом деле к отличиям, вроде замены наследования на способности, быстро привыкаешь. Как только глаза привыкли, руки набились, Rust превращается во вполне рабочий язык, проще и функциональнее C++, но уступающий по «красивости» многим другим языкам программирования. Фактически же главное отличие Rust от конкурентов и предшественников — именно скорость и безопасность.

Востребованность

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

Еще востребованного: профессия « ».

Перевод статьи Федерико Мена-Кинтеро, который, наряду с Мигелем де Икаса, основал проект GNOME - широко используемую, свободную графическую среду, в основном для систем GNU/Linux. Перед этим он некоторое время поддерживал GIMP . Сейчас Федерико активно развивает библиотеку librsvg с использованием языка программирования Rust. По его мнению, разработка достигла момента, когда портирование некоторых крупных компонент с C на Rust выглядит более лёгкой задачей, чем просто добавление аксессоров к ним. Федерико часто приходится переключаться с C на Rust и обратно, и в статье он рассказывает, почему считает C очень и очень примитивным языком для современного ПО.

Своего рода элегия по C

Я влюбился в язык программирования C около 24-ёх лет назад. Я выучил основы, прочитав испанский перевод второго издания «Языка программирования C» Кернигана/Ритчи (K&R) . До этого я писал на Turbo Pascal в довольно низкоуровневой манере - с указателями и ручным выделением памяти. После него C казался освежающим и мощным.

К&R - это отличная книга благодаря стилю изложения и лаконичности программирования. Эта книга даже учит, как реализовать простые функции malloc/free , что крайне поучительно. Даже такие низкоуровневые конструкции, которые выглядят как часть языка, могут быть реализованы на самом языке!

В последующие годы я хорошо освоил C. Это простой язык с небольшой стандартной библиотекой. Наверное, это был идеальный язык для реализации ядер Unix в 20 000 строк кода или около того.

GIMP и GTK+ научили меня тому, как использовать модный объектно-ориентированный подход в C. GNOME показал, как поддерживать крупномасштабные проекты, написанные на C. Стало казаться, что 20 000 строк C кода - это проект, который можно практически полностью понять за пару недель.

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

Опыт использования C

Положительный

• Чтение исходного кода проекта POV-Ray впервые и изучение того, как использовать объектно-ориентированный подход и наследование в чистом C;
• Чтение исходного кода проекта GTK+ и изучение читаемого, поддерживаемого и чистого стиля написания кода на C;
• Чтение исходного кода проекта SIOD, а также ранних исходников проекта Guile и понимание того, как интерпретатор Scheme может быть написан на C;
• Написание первых версий Eye of Gnome и доработка системы микротайлового рендеринга.

Негативный

• Работа в команде Evolution, когда программа постоянно падала. Мы были вынуждены приобрести машину с Solaris на борту, чтобы иметь возможность купить Purify; в те времена Valgrind-а еще не существовало;
• Отладка взаимных блокировок потоков в gnome-vfs;
• Безуспешная отладка Mesa;
• Когда мне передали исходники первых версий Nautilus-share, я увидел, что free() вообще не используется;
• Попытки рефакторинга кода, о стратегии управления памятью которого я не имел понятия;
• Попытка сделать библиотеку из кода, кишащего глобальными переменными, и в котором ни одна функция не помечена как static .

Фичи Rust, которых не хватает в C

Автоматическое управление ресурсами

Один из первых блог-постов, которые я прочитал о Rust, назывался «В Rust вам никогда не придётся закрывать сокет» . Rust заимствует у C++ идеи об идиоме (Resource Acquisition Is Initialization, получение ресурса есть инициализация) и умных указателях, добавляет принцип единоличного владения для значений и предоставляет механизм автоматического, детерминированного управления ресурсами в очень изящной упаковке.

• Автоматическое: не нужно вызывать free() вручную. Память освободится, файлы закроются, мьютексы разблокируются, когда переменные выйдут из зоны видимости. Если вам нужно написать обёртку для стороннего ресурса, то всё, что нужно сделать, это реализовать типаж Drop. Обёрнутый ресурс ощущается как часть языка, потому что вам не приходится нянчиться с его временем жизни вручную;
• Детерминированное: ресурсы создаются (память выделяется и инициализируется, файлы открываются и т. д.) и уничтожаются, когда выходят из зоны видимости. Никакой сборки мусора: ресурсы действительно освобождаются, когда вы закрываете скобку. Вы начинаете видеть время жизни данных в своей программе как дерево вызовов функций.

После того, как постоянно забываешь освобождать/закрывать/уничтожать объекты в C, или, ещё хуже, пытаешься понять, где в чужом коде забыли сделать что-то из этого (или ошибочно сделали дважды )… я просто больше этого не хочу.

Дженерики

Vec - это действительно вектор, размер элементов которого равен размеру объекта типа T . Это не массив указателей на объекты, память для которых выделялась отдельно. Он специально компилируется в код, который может работать только с объектами типа T .

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

Типажи - это больше, чем просто интерфейсы

Rust - это не Java-подобный объектно-ориентированный язык, подробнее об этом можно прочитать в open-source книге «The Rust Programming Language» . Вместо этого в нём есть типажи, которые поначалу похожи на интерфейсы в Java, - простой способ осуществления динамического переключения (dynamic dispatch), так что если объект реализует Drawable , то можно предположить, что у него есть метод draw() .

Однако типажи - это более мощный инструмент. Одной из отличительных особенностей типажей можно считать ассоциированные типы (associated types). Например, Rust предоставляет типаж Iterator , который вы можете реализовать:

Pub trait Iterator { type Item; fn next(&mut self) -> Option; }

Это означает, что всякий раз, когда вы реализуете этот типаж для какого-либо объекта, поддерживающего итерирование, вы также указываете тип Item для значений, которые он выдаёт. Если вы вызываете next() и элементы ещё остались, вы получите Some(ТипВашегоЭлемента) . Когда у вашего итератора закончатся элементы, он вернет None .

Ассоциированные типы могут ссылаться на другие типажи.

Например, в Rust вы можете использовать циклы for со всем, что реализует типаж IntoIterator:

Pub trait IntoIterator { /// Тип элементов, по которым идёт итерация type Item; /// В какой тип итератора мы преобразуемся? type IntoIter: Iterator; fn into_iter(self) -> Self::IntoIter; }

Когда реализуете этот типаж, вы должны указать и тип элементов, которые будет выдавать ваш итератор, и сам тип IntoIter , который реализует типаж Iterator и хранит состояние вашего итератора.

Таким образом, вы можете построить настоящую сеть типов, которые ссылаются друг на друга. Вы можете написать типаж, который говорит: «Я могу сделать foo и bar, но только если вы дадите мне тип, который умеет делать вот это и это».

Срезы

Я уже писал о том, насколько в C не хватает срезов (slices) для работы со строками и какая это головная боль, когда привык, что они под рукой.

Современные инструменты для управления зависимостями

Вместо того, чтобы

• Запускать pkg-config руками или через Autotools-макрос;
• Сражаться с include-путями в заголовочных файлах…
• … и библиотечных файлах;
• И, по сути, полагаться на то, что пользователь гарантирует установку верных версий библиотек,

вы пишете файл Cargo.toml , в котором перечисляются названия и версии всех наших зависимостей. Они будут загружены из общеизвестного источника или из любого другого, указанного вами.

Не нужно сражаться с зависимостями. Оно просто работает, когда вы набираете cargo build .

Тесты

В C очень сложно покрывать код тестами по нескольким причинам:

• Внутренние функции часто помечены как static . Это означает, что они не могут быть вызваны вне файла, в котором эта функция определена. Тестовая программа вынуждена либо #include -ить содержимое исходника, в котором функция объявлена, либо использовать #ifdef , чтобы убирать static только при тестировании;
• Вам придётся плясать с бубном вокруг вашего Makefile, чтобы слинковать тестовую программу с определённой частью зависимостей основной или с какой-то частью оставшейся программы;
• Вам придётся выбрать фреймворк для тестирования. Вам придётся зарегистрировать свои тесты в фреймворке для тестирования. Вам придётся изучить этот фреймворк.

В Rust вы пишете

# fn test_that_foo_works() { assert!(foo() == expected_result); }

в любом месте программы или библиотеки, и, когда вы набираете cargo test , ОНО ПРОСТО, *****, РАБОТАЕТ. Этот код линкуется только в тестовый исполняемый файл. Не нужно ничего компилировать дважды вручную, писать Makefile-магию или разбираться, как вытащить внутренние функции для тестирования.

Для меня это одна из главных киллер-фич языка.

Документация с тестами

Rust генерирует документацию на основе комментариев, размеченных с помощью Markdown. Код из документации запускается как обычные тесты . Вы можете показывать, как функция должна использоваться, одновременно тестируя её:

/// Multiples the specified number by two /// /// ``` /// assert_eq!(multiply_by_two(5), 10); /// ``` fn multiply_by_two(x: i32) -> i32 { x * 2 }

Код из примера запускается как тест, чтобы убедиться, что ваша документация своевременно обновляется вместе с кодом программы.

Гигиеничные макросы

В Rust особые гигиеничные макросы, позволяющие избежать проблем, при которых во время разворачивания C макросов происходит непреднамеренное затенение идентификаторов в коде. Вам больше не нужно писать макросы, заключая все символы в скобки, чтобы max(5 + 3, 4) работал правильно.

Никакого неявного приведения типов

Все эти баги, которые появляются в C из-за непреднамеренного приведения int к short или к char и т. п. - в Rust их нет. Вы должны приводить типы явно.

Никакого целочисленного переполнения

Этим всё сказано.

Как правило, никакого неопределённого поведения в безопасном режиме

В Rust, если что-то вызывает неопределенное поведение в «безопасном режиме» (всё, что написано вне блоков unsafe {}), это расценивается как баг самого языка. Например, можно сделать побитовый сдвиг отрицательного целого числа вправо и произойдёт именно то, что вы ожидаете.

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

Знаете, как gcc выдает предупреждение, если вы используете switch() с перечислением (enum), но обработаете не все варианты? Это детский сад по сравнению с Rust.

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

Impl f64 { pub fn sin_cos(self) -> (f64, f64); } let angle: f64 = 42.0; let (sin_angle, cos_angle) = angle.sin_cos();

match работает на строках. ВЫ МОЖЕТЕ МАТЧИТЬ ГРЁБАНЫЕ СТРОКИ.

Let color = "зеленый"; match color { "красный" => println!("Это красный"), "зеленый" => println!("Это зеленый"), _ => println!("Что-то другое"), }

Вы же знаете, насколько такое плохо читается?

my_func(true, false, false)

Как насчет того, чтобы вместо этого использовать сопоставление с образцом на аргументах функции:

Pub struct Fubarize(pub bool); pub struct Frobnify(pub bool); pub struct Bazificate(pub bool); fn my_func(Fubarize(fub): Fubarize, Frobnify(frob): Frobnify, Bazificate(baz): Bazificate) { if fub { ...; } if frob && baz { ...; } } ... my_func(Fubarize(true), Frobnify(false), Bazificate(true));

Стандартная полезная обработка ошибок

Я подробно останавливался на этом. Больше никаких булевых возвращаемых значений без нормального описания ошибки, никаких случайно проигнорированных ошибок, никакой обработки исключительных ситуаций longjmp-ами.

#

Если вы пишете новый тип (скажем, структуру с кучей полей), то можно написать # , и Rust будет знать, как автоматически напечатать содержимое этого типа для отладки. Больше не нужно руками писать специальную функцию, которую затем придётся вызывать из gdb, только для того, чтобы посмотреть содержимое полей пользовательского типа.

Замыкания

Вам больше не придётся передавать указатели на функцию и user_data вручную.

Заключение

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

C - это старый язык с примитивными конструкциями и примитивными инструментами. Он хорошо подходил для небольших однопроцессорных Unix-ядер, которые работали в доверенных, академических средах. Но для современного программного обеспечения он больше не подходит.

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

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

Что общего у Rust и других языков?

В перечисленные определения сложно поверить, это выглядит нереалистичным заявлением, так как ранее все языки выбирали одну из сторон: надёжность или производительность.

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

Уклон в сторону надёжности лучшим образом демонстрирует язык Haskell , который имеет компилируемую природу и обеспечивает высокие показатели безопасности. Всё, что можно компилировать, будет исправно работать. Главный недостаток - это низкая производительность, сложно представить проект, требующий высокой скорости написанный на Haskell .

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

Rust вобрал в себя лучшие характеристики C++ и Haskell , а также смог сохранить достаточную практичность и функциональность от остальных конкурентов.

В чем же прелесть языка Rust?

Волшебные характеристики Rust стали доступными при помощи основ компилирования и информации о сущности владельца (owner ), о программисте, который только временно отлаживает или занял проект (mutable borrow ), а также об обычном зрителе (immutable borrow ).

При программировании на Java или же C++ , приходится удерживать данную информацию в памяти, хотя вид данных несколько отличается. В Rust это реализуется с помощью языковых конструкций, данная информация облегчает компилятору задачу установления личности и правильности подбора модели поведения. Благодаря компилятору можно гарантировать устранение потенциальных и частых проблем в ходе выполнения кода.

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

1. Полностью устранена система наследования, для замены используется особая структура и способности, подробнее traits .
2. Присутствуют указатели исключительно в коде, который не подвергается дополнительной защите, то есть внутри функции unsafe {} . Для их замены в безопасном коде используются ссылки, которые обеспечивают правильное указание на имеющиеся объекты.
3. Если ссылка статическая и ведёт к определённому элементу, например, immutable borrow = &Object , до момента смерти ссылки она не может изменяться любым пользователем.
4. При наличии изменяющейся ссылки mutable borrow = &mut Object , нельзя прочитать содержимое любому другому пользователю весь период жизни ссылки.
5. Разработчики делают акцент на Mac и *nix платформы, из-за этого работать на системе Windows можно только с использованием среды GNU .

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

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

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

Следить за изменениями в языке программирования помогает постоянная рубрика «This Week in Rust », которую можно найти в Rust "n Stuffs по ссылке . Здесь всегда есть информация о предшествующих и прошедших изменениях, а также перспективах развития языка.

Уже сейчас вы могли обратить внимание на то, что синтаксис рассматриваемого языка программирования очень похож на синтаксис таких языков, как C/C++, ведь в обоих случаях для выделения комментариев используются два слэша, блоки кода обрамляются фигурными скобками, а аргументы функций - круглыми скобками. Также следует помнить о том, что для объявления функций используется ключевое слово fn , причем каждая программа должна иметь функцию main() . Восклицательный знак после имени функции println в данном случае указывает на то, что используется макрос (по сути, это удобная обертка над функцией print из библиотеки времени исполнения Rust).

Для компиляции программы следует просто выполнить команду:

Rustc hello.rs

В результате в директории с файлом исходного кода программы должен появиться бинарный файл с именем hello , для исполнения которого достаточно выполнить команду./hello . Но если вы обратите внимание на размер этого файла, вы будете в некоторой степени шокированы: он будет превышать 800 КБ. И все это нужно для работы такой простой программы? Ну, по умолчанию компилятор Rust осуществляет статическое связывание большей части библиотек времени исполнения с программой, поэтому вы можете скопировать бинарный файл в систему, в которой не установлено библиотек времени исполнения Rust и запустить его без каких-либо проблем. Однако, вы также можете сообщить компилятору о необходимости выполнения оптимизаций и динамического связывания:

Rustc -O C prefer-dynamic hello.rs

Теперь вы получите бинарный файл более приемлемого размера, равного 8 КБ, но в случае использования утилиты ldd вы обнаружите, что для корректной работы программы требуется наличие в системе динамической библиотеки libstd-<версия>.so .

Синтаксис языка программирования

Теперь, когда мы можем компилировать и запускать программы на Rust, я предлагаю разобраться с синтаксисом данного языка программирования и особо выделить его отличия от синтаксиса таких языков программирования, как C, C++ и других аналогичных:

Fn doubler (x: i32) -> i32 { x * 2 } fn main () { let a: i32 = 5; let b; b = doubler(a); println!("a, умноженное на 2 {}", b); match b { 1 ... 10 => println!("От 1 до 10"), _ => println!("Другое число"), } }

Если вы привыкли работать с языками C/C++, вы можете подумать, что данный код является каким-то странным, но он вполне логичен. Давайте начнем рассмотрение с функции main() : в первой строке let мы объявляем 32-битную целочисленную переменную a и присваиваем ей начальное значение 5. Мы могли бы пропустить указание типа переменной (i32 является стандартным типом переменных), а также не присваивать ей начальное значение, причем в этом случае она содержала бы нулевое значение. Обратите внимание на то, что при объявлении переменной и присваивании ей определенного значения таким же образом, как в случае переменной a из примера, вы не сможете впоследствии изменить ее значение, поэтому при компиляции следующего фрагмента кода будет сгенерировано сообщение об ошибке:

Let a: i32 = 5; a = 10;

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

Let mut a: i32 = 5;

Для чего же это нужно? Это ведь лишняя работа, не так ли? Ну, по сути это действительно так, но, с другой стороны, данная особенность языка программирования помогает разрабатывать безопасные программы. Вы должны делать изменяемыми лишь те переменные, значения которых действительно должны изменяться. Rust заставляет вас быть настолько многословным, насколько это необходимо для максимально точного описания принципа работы программы: в строке выше приведено объявление знаковой целочисленной переменной a размером ровно в 32 бита с возможностью изменения ее значения в будущем.

Далее мы вызываем нашу функцию doubler с переменной a в качестве аргумента и сохраняем возвращаемое значение в переменной b . Обратите внимание на объявление функции doubler , которое находится в начале кода программы: в нем указывается тип параметра функции (i32) и тип возвращаемого значения (i32) после символов ->. Также несложно заметить, что в рамках функции выполняется единственная операция x * 2 , после которой даже не следует символа точки с запятой, как в обычном блоке кода на языке Rust; что же происходит там?

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

Вернемся в функцию main() , в которой мы использовали макрос println!() для вывода результата; обратите внимание на методику подстановки значения переменной с помощью последовательности символов {} . Наконец, в примере демонстрируется чрезвычайно полезное ключевое слово "match" языка программирования Rust, которое позволяет значительно сократить объем кода в том случае, если вам необходимо выполнить большое количество операций if/else. В данном случае 1 … 10 является объявлением диапазона значений (от 1 до 10 включительно), а символ подчеркивания (_) соответствует всем остальным значениям.

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

Let x = (1, 2.0, "Hello");

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

Println!("{}", x.2);

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

Fn switch(input: (i32, i32)) -> (i32, i32) { (input.1, input.0) } fn main() { let x = (10, 50); let y = switch(x); println!("{}, {}", y.0, y.1); }

В данном случае функция с именем switch() принимает кортеж с двумя 32-битными целочисленными значениями и сохраняет их в переменной input . При этом она также возвращает кортеж с двумя целочисленными значениями. В рамках данной функции используется простое выражение, позволяющее поменять местами элементы кортежа и вернуть получившийся кортеж.

В рамках функции main() создается кортеж с именем x , содержащий значения 10 и 50, а также кортеж с именем y , содержащий значения, которые были возвращены после вызова функции switch() . Далее осуществляется простой вывод значений кортежа на экран (50, 10).

Совет: Если вам не терпится самостоятельно разобраться с возможностями Rust, рекомендуем начать с чтения официальной документации, расположенной по адресу https://doc.rust-lang.org/book .

Это было краткое описание синтаксиса и возможностей языка программирования 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. Не буду исчерпывающе описывать синтаксис языка, а остановлюсь только на наиболее интересных концепциях.