Cargo наполнил этот файл значениями по умолчанию на основании переданных аргументов и глобальной конфигурации git . Также он инициализировал директорию hello_world как git репозиторий.

Вот что должно быть внутри src/main.rs:

Cargo создал «Hello World!» для нас, и вы уже можете приступить к программированию!

У Cargo есть собственное руководство , в котором про него рассказано более детально.

Заключение

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

У вас есть два пути: погрузиться в изучение реального проекта, открыв раздел «Изучение Rust », или начать с самого низа и постепенно продвигаться наверх, начав с раздела «Синтаксис и семантика ». Программисты, имеющие опыт работы с системными языками, вероятно, предпочтут «Изучение Rust», в то время как программисты, имеющие опыт работы с динамическими языками, скорее всего, захотят пойти по второму пути. Разные люди учатся по-разному! Выберите то, что подходит именно вам.

В 2013 году компания Mozilla совместно с Samsung сообщила о разработке нового механизма веб-браузера Servo. Он создавался специально для многоядерных процессоров мобильных устройств, способен разбивать задачи на параллельные потоки и многократно уменьшать время загрузки веб-страниц. Servo полностью написан на языке программирования Rust, который Mozilla разработала сама для написания мобильных приложений.

О языке

Rust - процедурный язык программирования, поддерживающий различные стили написания кода. Разработчик Грэйдон Хор начал создавать язык в 2006 году, и спустя три года к проекту подключилась Mozilla. В 2010 году Rust презентовали на конференции Mozilla Summit. В этом же году разработку перевели на компилятор, написанный на Rust. Компилятор использовал универсальную систему анализа и трансформации программ LLVM в качестве базы данных.

Первая стабильная версия языка вышла в 2015 году. После релиза альфа-версии Rust подвергся правкам - внутри компилятора оставили только готовые возможности, которые не будут изменяться. Все остальное перенесли в экспериментальный раздел.

В основе языка Грэйдон Хор заложил такие понятия как:

• Безопасность. Rust содержит ряд ограничений для программиста, которые включены по умолчанию. Для их отключения в блоках и функциях требуется метка «unsafe».
• Скорость. Язык сопоставим по скорости с другим языком программирования C++, что дает явный ряд преимуществ для программиста.
• Параллелизм. Система может выполнять несколько вычислений одновременно, вместе с этим они могут взаимодействовать друг с другом.
• Краткость. Первые ключевые слова в Rust укладывались в пять символов. Но позднее это ограничение сняли.

Пример одного из первых кодов на Rust

Однако Rust не лишен и минусов, самые яркие из них:

• Избыточность кода.
• Отсутствие литературы для изучения языка.
• Четкость во внесении параметров компиляции. Это не всегда устраивает опытных программистов, так как в других языках подобных правил нет.

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

Сравнение Rust с C++

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

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

Именно на C++ был реализован Firefox: этот капризный язык требовал повышенного внимания к деталям. В противном случае ошибки оборачивались серьезными уязвимостями. Rust был призван справиться с этой проблемой.

Перспективы

В рейтинге RedMonk за третий квартал 2018 года язык программирования от Mozilla стабильно занимает 23 место. Эксперты полагают, что улучшение позиций ему не грозит. Несмотря на это, в августе 2018 года создатели выпустили обновленный Rust 1.28.

После релиза Rust в 2015 году, по данным площадки Stack Overflow , с ним хотели ознакомиться 74% разработчиков. Однако уже в 2016 году он переместился на первое место: 79% пользователей назвали Rust любимым языком программирования и изъявили желание продолжить работу с ним. Первое место по этому параметру Rust занял и в 2018 году.

Stack Overflow — популярная система вопросов и ответов о программировании, разработанная в 2008 году.

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

Я новичок в языке 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 с помощью:

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, используя команду:

Скомпилировав получим соответствующий исполняемый файл:

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 отсутствует встроенная поддержка объединений, так что нам придётся выработать стратегию самостоятельно. В С объединение - это тип, который хранит разные типы данных в одной области памяти. Существует много причин, по которым можно отдать предпочтение объединению, такие как: преобразование между бинарными представлениями целых чисел и чисел с плавающей точкой, реализация псевдо-полиморфизма и прямой доступ к битам. Я сфокусируюсь на псевдо-полиморфизме.

Перевод статьи Федерико Мена-Кинтеро, который, наряду с Мигелем де Икаса, основал проект 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 непросто освоить, но я уверен, что это того стоит. Сложность в том, что язык требует от вас глубокого понимания кода, который вы хотите написать. Я думаю, что это один из тех языков, которые делают вас лучше как программиста и позволяют решать более амбициозные проблемы.