На чем написан rust язык

Rust — молодой и дерзкий язык программирования

Говорят, что это одновременно C++ и Haskell.

Первая версия языка Rust появилась в 2010 году, и он сразу занял третью строчку в списке любимых языков разработчиков на StackOverflow. Год спустя Rust возглавил этот список и держался там несколько лет. Давайте посмотрим, почему этот язык стал таким популярным, в чём его особенности и почему вокруг него много споров.

В чём идея языка Rust

Автору языка нравилась скорость работы и всемогущество языка C++ и надёжность Haskell. Он поставил перед собой задачу совместить оба этих подхода в одном языке, и за несколько лет он собрал первую версию языка Rust.

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

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

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

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

Синтаксис и код

За основу синтаксиса в Rust взят синтаксис из C и C++.Например, классический «Привет, мир!» на Rust выглядит так:

fn main() <
println!(«Hello, world!»);
>

Если вы знакомы с подобным синтаксисом, то сможете быстро начать писать и на Rust. Другое дело, что в Rust есть свои особенности:

let x = if new_game() < 4 >
else if reload() < 3 >
else

Последнее разберём подробно. При такой записи переменная x будет равна четырём, если функция new_game() вернёт значение true. Если этого не случится, компилятор вызовет функцию reload() и проверит, что получилось. Если true, то x примет значение 3, а если и это не сработает — то x станет равным 0.

Ещё в Rust есть сравнение переменной с образцом. В зависимости от того, с каким образцом совпало значение переменной, выполнится та или иная функция:

Главная особенность программ на Rust

Несмотря на синтаксис, похожий на C, главную особенность программ на Rust разработчики взяли из Haskell, и звучит она так:

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

Это значит, что программы на Rust почти так же надёжны, как программы на Haskell. Почти — потому что если программист использует «небезопасный» блок unsafe, который даёт ему прямой доступ к памяти, то в теории это иногда может привести к сбоям. Но даже с такими блоками Rust старается справляться сам и падает только в безнадёжных случаях.

Плюсы и минусы языка

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

Минусы в основном связаны со скоростью развития языка. Так как Rust развивается очень быстро, то часто бывает так, что код из старой версии не работает в новой версии. Ещё к минусам можно добавить:

Что написано на Rust

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

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

Источник

Погружаемся в логово ржавчины. Как работает компилятор rust

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

Словарь

ICE (Internal compiler error), ошибка компилятора.

Дальнейший текст подразумевает, что вы умеете программировать. Можно и не на rust.

Начало

Поехали. Мы будем лезть нашими ручками в сам компилятор и смотреть на его исходники. Для начала нам понадобятся кое-какие инструменты. Ставим чистую виртуальную машину с Windows 10. Идём в интернеты и льём следующее:

Сорцы компилятора. Достаются с github. Можно лить просто zip, ибо обратно коммитить мы ничего не будем.

Установщик компилятора. Любая свежая стабильная версия подойдёт.

Guide to Rustc Development. Инструкция по разработке компилятора. 460 страниц. Не хило. Сохраняем pdf.

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

Ок, это было просто. Но мы не будем использовать cargo для самой компиляции. Используем компилятор напрямую. Но я же на надо cargo издеваюсь, так ведь?

Отступление по теме

Как не надо устанавливать rust

Чего? Так, сам по себе компилятор всё собрал, но ругается на отсутствие линкера. От жеж, зараза. То есть, линкер ему нужен внешний. Ругаемся на компилятор, встаём с удобного кресла и идём обратно, подключаться к проводному интернету, потому что палить 5 гигов установщика Visual Studio Build Tools не хочется на хотспоте.

Билдим всё ещё раз и смотрим.

Ширина и жирина файлов.

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

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

Шаг первый: rustc

Открываем сорцы и наслаждаемся. Всё выглядит очень прилично и чисто. Тут, понятное дело, можно учиться тому как правильно разделять свой проект на куски и как правильно управлять кодом на rust. Собственно говоря, сразу понятно куда идти. Забираемся в compiler/rustc/src/main.rs и смотрим.

Всё только начинается. Держитесь.

Хм. То есть точка входа в программу просто тянет jemalloc вызовы и запускает ещё две функции. Ну вот, всё. Теперь понятно как работает компилятор rust. Делов-то! Кстати, jemalloc это специальный менеджер памяти, изначально разработанный для FreeBSD в 2005 году. Основной упор был сделан на то, чтобы избежать фрагментации памяти при работе с этим аллокатором. В оригинальной версии он просто заменяет malloc. В 2007 году Firefox начал использовать этот менеджер для снижения расхода памяти, а ещё через пару лет он попал в Facebook.

Шаг второй: rustc-driver

Ладно, всё выглядит слишком уж просто. Погружаемся дальше. rustc тянет за собой rustc-driver. Ныряем туда.

Тут мы найдём небольшой readme, который расскажет нам о том, что компилятора в самом драйвере мы не найдём. Эта программа собирает конфигурацию из аргументов и запускает сам процесс компиляции из других крейтов. После изучения исходников находим функцию для запуска процесса компиляции.

Да, в этом крейте файлов не так-то много, но что бы тут не творилось, на самом деле всё сводится к вызову методов в крейте под названием interface. Вышеприведённый код это и показывает. interface::run_compiler и поехали.

Что же произошло в rustc-driver? Мы собрали все конфиги. Подгрузили все файлы и нашли их местоположение в файловой системе. Создали замыкание, которое следит за процессом компиляции и запускает линкер после успешной компиляции. Запустили линтеры (если такие имелись) и приготовили сам компилятор к запуску. Давайте запускать.

Шак третий: rustc-interface

Ага. Тут мы уже ближе к самому процессу компиляции. Все конфиги подъедены, файлы тоже замеплены. Смотрим на исходники интерфейса. Их хоть и не так-то много, но это наш центральный вокзал, где куча других крейтов собирается воедино.

Так, осматриваемся и находим

Кстати тут же, недалеко, мы можем найти настройку механизма кодогенерации.

Быстренько посмотрим на наши сорцы и увидим что у нас прямо в сорцах есть 3 различных модуля кодогенерации. Что они делают? Превращают MIR в конечный код для системы компиляции. Открываем rustc-codegen-llvm и смотрим в README:

Ок, ну тут всё понятно, мы берём MIR и переделываем его в LLVM IR. После этого LLVM может скомпилировать код в конечный бинарник. Но погодите, помимо LLVM бекенда у нас есть ещё два других! Смотрим туда. rustc-codegen-ssa согласно документации, позволяет генерировать низкоуровневый код, который не будет привязан к определённому бекэнду (например, LLVM) и позволит в дальнейшем использовать другие системы компиляции.

Собственно говоря, прямо там же вы найдёте rustc-codegen-cranelift. То есть MIR в будущем может компилироваться через cranelift, который в идеале ускорит процесс компиляции. Ну это в будущем, пока что проект в процессе тестирования и работает не лучше, чем Газель без мотора.

Открываем модуль и смотрим, что происходит внутри:

Ага, вот тут мы берём быка за рога и начинаем разбирать исходный код на части. Далее, создаём и проверяем AST

Даже если вы и поменяли что-то в каком-либо файле, то благодаря системе запросов вы сможете избежать ненужной перекомпиляции. Что если вы изменили только одну линию в комментариях к файлу? Пересобирать такой не придётся.

Давайте посмотрим на запросы, которые создаёт компилятор:

В итоге у нас на выходе получается большая и толстая структура:

И как раз её можно дёргать для выполнения необходимых запросов.

Шаг четвёртый: rustc-parse и rustc-lexer

Далее по тексту вы найдёте простую логику всех этих запросов. «Простая» логика заключается в вызове крейтов, которые её обрабатывают. Например, rustc-parse. Это крейт, который использует rustc-lexer. Лексер читает строки из файлов и преобразовывает их в очень простые токены. Токены передаются парсеру, который превращает их в Span и продолжает работу с кодом. Основной момент этого Span заключается в том, что к каждому элементу в дереве кода будет добавлена информация о том, в каком конкретно месте этот элемент записан в исходном файле. Когда компилятор будет сообщать об ошибке, вы увидите, где именно эта ошибка произошла.

Шаг пятый: rustc-expand

В результате работы парсера мы получаем наш самый великий и могучий AST.

Всё это создаётся огромным макросом astfragments! в \compiler\rustcexpand\src\expand.rs

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

Шаг шестой: rustc-middle

Этим как раз и занимается rustc-middle. Вернее, не только этим. Залезаем в исходники и видим что тут у нас есть HIR, MIR и Types.

Здесь весь синтаксический сахар растворяется в чае и перестаёт быть сахаром. Так моя любимая for node in data превращается в

С HIR теперь можно работать…

Шаг седьмой: rustc_ty

Последняя тянется через весь процесс компиляции.

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

Кстати, смотрим в rust-master\compiler\rustc_typeck\src\check\expr.rs

Компилируем и запускаем:

Пасхалки они выглядят именно вот так.

Так, вычислили типы и теперь можем проверить что никто не пытается запихнуть строку в Int. Хорошо. Можно идти дальше.

Шаг восьмой: rustc_mir и rustc_mir_build

Теперь наш HIR можно преобразовать в MIR. Берём ранее созданный TyCtxt и начинаем преобразовывать его в

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

Шаг девятый: Проверка заимствования

Самая «страшная» функция rust это всем известный borrow cheker. Сам он живёт в

Шаг десятый: Оптимизации

Шак одиннадцатый: прощай, rust!

Полученный оптимизированный MIR можно теперь переделать в LLVM IR. Поехали. rustc-codegen-llvm создаёт LLVM-IR на базе MIR, который мы сгенерировали на предыдущем этапе. Здесь заканчивается rust и начинается llvm. Хотя, мы ещё не закончили с сорцами компилятора.

Копаемся чуть глубже и находим rustc-target в котором видим различные дополнительные классы для работы с определённым ассемблером.

После того как кодогенерация завершена, мы можем передать IR в сам LLVM. rustc_llvm нам в помощь.

Вот, собственно говоря, и всё, ребята! LLVM за пределами нашей видимости. На моей операционной системе Visual Studio Build Tools берут на себя контроль и перегоняют LLVMIR в обычный бинарник.

Он парсится из текста в AST.

AST обрабатывается и оптимизируется в HIR

HIR обрабатывается и оптимизируется в MIR.

MIR делает проверки заимствования и оптимизацию и перегоняется в LLVMIR.

LLVMIR компилируется на конечной платформе.

Пробуем ручками

Ну что же, напоследок осталось написать простенькую программку, типа этого:

И начать её компилировать, только показывая все внутренности. Для начала есть замечательная опция компилятора, которая работает на любой версии:

Значит, запуская компиляцию следующим образом:

Мы получаем на выходе мириады различных форматов, включая сгенерированный ассемблеровский код, байткод и IR для LLVM, и даже челвоеко-читаемый MIR.

А если у вас есть nightly компилятор, то вы можете запустить

И полюбоваться вашим HIR, в то время как

Даст вам возможность посмотреть на то, как выглядит AST.

Напоследок

Ну что же, мы залезли в дебри компилятора. Теперь вы знаете, что происходит каждый раз когда вы запускаете билд на своей машине. Я показал вам rust. Но не бойтесь, ваш любимый язык, скорее всего, ничуть не менее сложен. Проще будет только компилировать ассемблер для 386 под досом. И не важно, если вы запускаете C#, Java, Javascript, Golang или haskell. Происходить будет многое, хотя и совсем по-разному.

Понятно? Ну и хорошо.

Постскриптум

Источник

Введение в программирование на Rust

Apr 17 · 12 min read

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

В 2020 году по итогам опроса разработчиков Stack Overflow самым любимым языком программирования уже пятый год подряд был признан Rust. Многие разработчики уверены в том, что Rust скоро обгонит C и C++ благодаря своему средству проверки заимствований и решению давних проблем, таких как управление памятью, а также неявная и явная типизация.

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

Вот что мы рассмотрим в статье.

Что такое Rust?

Rust — это мультипарадигмальный статически типизированный язык программирования с открытым исходным кодом, используемый для создания операционных систем, компиляторов и других программно-аппаратных средств. Он был разработан Грейдоном Хором в Mozilla Research в 2010 году.

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

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

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

Зачем изучать Rust?

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

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

«Hello World!» на Rust

Разберем все части этого кода.

fn — это сокращение от function («Функция»). В Rust (как и в большинстве других языков программирования) функция как бы говорит: «Сообщите мне информацию, а я сделаю то-то и то-то и затем дам ответ».

Функция main — это то место, где начинается программа.

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

Дальше идет строка. Строки состоят из нескольких собранных вместе букв или символов. Для обозначения строки эти символы помещаются в кавычки ( » ). Затем строки передаются для макросов типа println! и других функций, с которыми мы еще поиграем.

А это точка с запятой. Она обозначает конец одной инструкции, как точка в предложении. Инструкции — это указания компьютеру выполнить конкретное действие. Чаще всего инструкция состоит из всего одной строки кода. В нашем случае она вызывает макрос. Есть и другие виды инструкций, которые мы скоро увидим.

Основы синтаксиса Rust

Теперь рассмотрим основные части программы на Rust и способы их реализации.

Переменные и их изменяемость

Переменные — это точки данных, которые сохраняются и помечаются для последующего использования. Формат объявлений переменных таков:

Имя переменной должно быть информативным, т. е. описывать, чем является ее значение. Например:

Совет💡 Всегда давайте переменным названия, начинающиеся со строчной буквы, а новое слово начинайте с заглавной.

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

Например, вот этот код выдаст ошибку во время компиляции:

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

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

Чтобы переопределить это значение по умолчанию и создать изменяемую переменную, объявим ее вот так:

Типы данных

Пока что мы видели, что значения переменных задаются либо с помощью фраз (называемых строками), либо целых чисел. Эти переменные представляют собой различные типы данных, которые обозначают, какой вид имеют содержащиеся в них значения и какие операции они выполняют.

В этом случае наш пример с объявлением my_name будет переписан следующим образом:

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

Во избежание недопонимания со стороны других разработчиков и для недопущения синтаксической ошибки поменяем объявление следующим образом:

Основные типы на Rust:

Функции

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

Вот формат для объявления функции:

Это уже знакомое нам сокращение от function («Функция»). За ним в коде Rust следует объявление функции.

Здесь находится идентификатор функции, который будет использоваться при ее вызове.

Эти скобки заполняются любыми параметрами, которые нужны функции. В данном случае никаких параметров не передается, поэтому скобки оставлены пустыми.

А здесь передаваемому значению присваивается имя. Это имя выступает в роли имени переменной, ссылающейся на параметр в любом месте тела функции.

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

Фигурные скобки обозначают начало и конец блока кода. Код внутри скобок выполняется при каждом вызове идентификатора функции.

А это заполнитель для кода функции. Лучше не включать сюда никакого кода, не связанного прямо с выполнением задачи функции.

Добавим немного кода. Переделаем hello-world в функцию say_hello() :

Совет💡 Увидели () — значит, вы имеете дело с вызовом функции. Если параметров нет, получаем внутри скобок пустое поле параметров. Сами скобки все равно остаются, указывая на то, что это функция.

Вот как будет выглядеть полная программа:

Комментарии

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

Совет💡 используйте комментарии для «закомментирования» разделов кода, выполнение которых не требуется, но которые позже понадобится добавить.

Условные инструкции

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

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

Вот как выглядит формат оператора if :

Совет💡 необходимо, чтобы в циклах while проверяемая переменная была изменяемой. Если переменная никогда не меняется, такой цикл будет продолжаться бесконечно.

Промежуточный Rust: владение и структуры

Владение

Владение — это центральная особенность Rust и одна из причин такой его популярности.

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

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

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

Вот эти правила владения.

А теперь посмотрим, как владение уживается с функциями. Для объявленных переменных память выделяется, пока они используются. Если эти переменные передаются в качестве параметров в другую функцию, выделение перемещается или копируется к другому владельцу и используется у него.

Структуры

Аналогом этих структур в таких языках, как Java и Python, являются классы.

Вот синтаксис объявления структуры:

Каждый создаваемый экземпляр типа Car должен иметь значения для этих полей. Поэтому создадим экземпляр Car для конкретного автомобиля со значениями для brand (модели) и year (года выпуска).

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

Вот как выглядит вся структура целиком:

В целом структуры отлично подходят для хранения вместе всей информации, относящейся к тому или иному типу объекта, для реализации и обращения к ней в программе.

Система сборки Rust: Cargo

Cargo — это система сборки и диспетчер пакетов Rust. Это важный инструмент для организации проектов на Rust. Здесь приводится перечень библиотек, необходимых проекту (они называются зависимостями). Он автоматически загружает любые отсутствующие зависимости и собирает программы на Rust из исходного кода.

Программы, с которыми мы имели дело до сих пор, достаточно просты, и поэтому зависимости для них не нужны. А вот при создании более сложных программ вам понадобится Cargo с возможностями инструментов, недоступных в рамках стандартной библиотеки. Cargo также используется для загрузки проектов в портфолио на GitHub, так как они хранят все части и зависимости вместе.

Если скачать Rust с официального сайта, Cargo автоматически устанавливается вместе с компилятором ( rustc ) и генератором документации ( rustdoc ) как часть набора инструментальных средств Rust. Убедиться, что Cargo установлен, помогает ввод в командной строке следующей команды:

Для создания проекта с Cargo запустите в интерфейсе командной строки операционной системы следующее:

Чтобы все это увидеть, наберите:

Продвинутые концепции для дальнейшего изучения

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

Источник