Что такое rust язык программирования

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

Пер­вая вер­сия язы­ка 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 был основ­ным язы­ком программирования:

Источник

Национальная библиотека им. Н. Э. Баумана
Bauman National Library

Персональные инструменты

Rust (язык программирования)

СпроектированоГрэйдон Хор, разработчики проекта RustСтабильная версия1.8 [1] / 14 апреля 2016 годаПечать дисциплиныстатическая, строгая, с выводом типов, опционально динамическаяГлавная реализацияrustcПод влияниемAlef, C++, Camlp4, Common Lisp, Erlang, Haskell, Hermes, Limbo, Napier, Napier88, Newsqueak, NIL, Sather, OCaml, Standard ML, Cyclone, Scheme [2]ВлияниеSwift

Rust —(произносится rʌst) мультипарадигмальный компилируемый язык программирования общего назначения, разрабатываемый Mozilla Research, поддерживающий функциональное программирование, модель акторов, процедурное программирование, объектно-ориентированное программирование.

Язык вырос из личного проекта сотрудника Mozilla Грэйдона Хора. Mozilla начали спонсировать проект в 2009 году и объявили его в 2010 г. Первый релиз компилятора Rust был в январе 2012. Rust 1.0, первый стабильный релиз, был выпущен 15 мая 2015 года. Хотя его развитие финансируется Mozilla, это open-source проект. Язык берет свое название от грибов семейства ржавчины.

Содержание

Обзор

Система поддерживает механизм, аналогичный типу классов, называемых «traits», вдохновленный непосредственно языком Haskell. Это средство для обеспечения однорангового полиморфизма достигается путем добавления ограничений на типы объявляемых переменных. Другие особенности от Haskell, такие как высшего многоранговый полиморфизм, пока не поддерживаются.

Синтаксис

Связанные переменные

Практически всякая программа сложнее ‘Hello world’ в Rust использует связанные переменные. Они выглядят так:

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

Rust является статически типизированным языком, что означает, что мы сначала указываем тип, и он проверяется во время компиляции. Типы указываются после двоеточия (:):

Если мы хотим, чтобы связывание было изменяемым, можно использовать слово mut:

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

Функции

Каждая программа в Rust имеет по крайней мере одну функцию main:

Это простейшее объявление функции. fn говорит: ‘это функция’, за этим следует имя, и скобки, потому что эта функция не принимает никаких аргументов, а затем фигурные скобки, чтобы указать тело.

Функция, которая инкрементирует на единицу целочисленное значение:

Простые типы

Rust имеет ряд типов, которые считаются «простыми». Это означает, что они встроены в язык. Rust структурирован таким образом, что стандартная библиотека также предоставляет ряд полезных типов.

Тип char представляет собой одно скалярное значение Unicode. Оно создается с помощью символов ‘ :

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

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

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

Если тип числа не указан явно, он определяется по умолчанию:

Ниже приведен список различных числовых типов:

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

Массивы имеют тип [T; N]. N является константой длины массива. Можно получить количество элементов в массив с помощью a.len ():

Можно получить доступ к определенному элементу массива:

Индексы начинаются с нуля, как и в большинстве языков программирования, так что первый элемент [0], а второй [1].

«Slice» является ссылкой на другую структуру данных. Они полезны для предоставления безопасного, эффективного доступа к части массива без копирования. Например, вы, возможно, захотите, ссылаться на всего одну строку в файл, считываемого в память. По своей природе, slice не создается непосредственно, а только от существующей переменной. Slice имеет свою длину, может быть изменяемым или нет, и во многих отношениях ведет себя как массив:

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

Скобки и запятые формируют этот кортеж. Вот тот же код, но с явно указанными типами:

Управление памятью

В Rust существует несколько типов указателей:

Неизменные (&Т) и изменяемые (&mut T) ссылки

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

Упаковка (Box )

Указатель на данные, размещаемые в куче; за один раз доступа к объекту можно использовать только один указатель.

Управляемые указатели со счетчиком ссылок (Rc ) и атомарные ссылки со счетчиком (Arc )

Указатели на данные, размещаемых в куче; несколько указателей могут отсылать к одному и тому же объекту. Arc позволяет получить доступ к разделяемому объекту.

Необрабатываемые указатели неизменяемые (* const Т) и изменяемые (* mut Т)

Указатели без гарантий безопасности. Не рекомендуется использовать их. Связывания являются неизменяемыми по умолчанию, и чтобы объявить переменную переменную, необходимо ключевое слово mut.

Объекты системы

В Rust объектная система основывается на признаках и структурах данных. Описание определяет типы и соответствующие методы и реализацию. Описание может включать в себя имплементацию методов по умолчанию. Имплементация обозначена ключевым словом impl.

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

Параллельные вычисления

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

Источник

Rust для разработчиков JS

Jul 27, 2020 · 7 min read

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

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

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

Что такое Rust?

Язык программирования Rust был создан компанией Mozilla, а его первая стабильная версия появилась на свет примерно в 2015 году. Hello, World на Rust выглядит так:

И совсем вроде не страшно. Можно даже сказать, что выглядит она почти как JavaScript, но это всего лишь программа hello world, а сама версия немного сложнее! Прежде чем переходить к функциональным средствам языка, давайте определим, какое место занимает Rust в окружении других языков программирования:

Между языками программирования существует чёткое разграничение:

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

Основные функциональные средства Rust

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

JavaScript — это динамически типизированный язык, позволяющий делать интересные штуки, например вычитать число 1 из строки wat и получать неожиданные результаты. Это стало возможно благодаря слабой системе типов. Если вы попытаетесь выполнить простое сложение двух чисел на Rust, которые не относятся к одному типу, вы получите ошибку компиляции:

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

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

Неизменяемость

В функциональных языках приходится много работать с неизменяемыми структурами. JavaScript программистов никто не заставляет работать с неизменяемостью, но популярные библиотеки, такие как Redux и Immutable.js, научили нас это делать. Сегодня есть ключевые слова let и const для объявления изменяемых и неизменяемых переменных соответственно.

Владение

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

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

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

Когда мы имеем дело с владением и заимствованием, Rust хочет, чтобы мы играли по правилам, поэтому он предупредит, если мы попытаемся сделать что-то не то:

Если при изучении владения и заимствования вам что-то непонятно, сбивает с толку или вы запутались, ничего страшного — это нормально! Ведь вы приступаете к теме управления памятью, а это непростая тема. Я рекомендую посмотреть вот это видео, чтобы подробнее узнать об этом.

Структуры

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

Что нужно, чтобы начать использовать Rust?

Первым делом нужно установить Rust. Нет ничего проще: заходите на сайт https://rustup.rs и загружаете официальный установщик набора инструментальных средств. Это то же, что и nvm, который обычно используется с JavaScript.

Затем вам понадобятся библиотеки — не начинать же всё совсем с нуля. Поэтому точно так же, как мы обзаводимся пакетами Node на JavaScript, мы будем поступать и с пакетами Rust. Зайдите на crates.io, официальное хранилище крейтов, чтобы подробнее разузнать о пакетах на Rust.

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

А если вы занимаетесь веб-разработкой, можно сказать, что вам повезло! Вы можете создавать программы, компилировать их и использовать всё это вместе с тем кодом, который у вас на JavaScript. WebAssembly — вот технология, которая сделала это реальным, и её можно использовать прямо сейчас во всех современных браузерах.

Если хотите её опробовать, рекомендую почитать официальную книгу с документацией по Rust и WebAssembly.

Заключение

Rust — это нереально крутой язык, который стоит освоить, ведь с его помощью столько всего можно сделать! Если вы веб-разработчик, как и я, то вам будет очень интересно читать о WebAssembly, и я надеюсь, что смогу сделать ещё статьи об этом.

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

В заключение отметим, что эта статья написана по мотивам доклада, представленного автором на семинаре разработчиков JS Coders meetup event. Со слайдами вы можете ознакомиться здесь.

Источник

The Rust Programming Language

Примечание: это издание книги так же, как и The Rust Programming Language доступно в печатном и электронном виде от No Starch Press.

Добро пожаловать в The Rust Programming Language, вводную книгу о Rust. Язык программирования Rust помогает создавать быстрые, более надёжные приложения. Хорошая эргономика и низкоуровневый контроль часто являются противоречивыми требованиями для дизайна языков программирования; Rust бросает вызов этому конфликту. Благодаря сбалансированности мощных технических возможностей c большим удобством разработки, Rust предоставляет возможности управления низкоуровневыми элементами (например, использование памяти) без трудностей, традиционно связанными с таким контролем.

Кому подходит Rust

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

Команды разработчиков

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

Rust также предлагает современные инструменты разработки для системного программирования:

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

Студенты

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

Компании

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

Разработчики Open Source

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

Люди, которые ценят скорость и стабильность

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

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

Для кого эта книга

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

Как использовать эту книгу

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

В этой книге вы найдёте два вида глав: концептуальные главы и главы проекта. В концептуальных главах вы узнаете об аспектах Rust. В главах проекта мы будем вместе строить небольшие программы, применяя то, что вы узнали. Главы 2, 12 и 20 являются главами проекта; остальные являются концептуальными главами.

В главе 1 объясняется, как установить Rust, написать программу “Hello, world!” и использовать сборщик Cargo и менеджер пакетов в одном лице. Глава 2 является практическим введением в язык Rust. В ней объясняются концепции верхнего уровня и в более поздних главах предоставляются дополнительные детали о них. Если хотите сразу погрузиться в практику, то для этого предназначена глава 2. Вначале можно даже пропустить главу 3, которая рассказывает про возможности языка аналогичные тем, что есть в других языках и перейти к главе 4, для изучения системы владения в Rust. Однако, если вы дотошный ученик, предпочитающий изучить каждую особенность до перехода к следующей, то можно пропустить главу 2 и перейти сразу к главе 3, возвращаясь к главе 2, если захочется поработать над проектом и применить полученные знания.

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

В главе 16 мы рассмотрим различные модели параллельного программирования и поговорим о том, как Rust помогает вам безбоязненно программировать в нескольких потоках. Глава 17 рассказывает о том, как идиомы Rust сравниваются с принципами объектно-ориентированного программирования, с которыми вы, возможно, знакомы.

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

В главе 20 мы завершим проект, в котором мы реализуем низкоуровневый многопоточный веб-сервер!

Наконец, некоторые приложения содержат полезную информацию о языке в формате, более похожем на справочник. В приложении A описаны ключевые слова Rust, в приложении B описаны операторы и символы Rust, в приложении C описаны производные свойства, предоставляемые стандартной библиотекой, в приложении D описаны некоторые полезные инструменты разработки, а в приложении E описаны редакции Rust.

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

Важной частью процесса обучения Rust является изучение того, как читать сообщения об ошибках, которые отображает компилятор: они приведут вас к работающему коду. Мы изучим много примеров, которые не компилируются и отображают ошибки в сообщениях компилятора в разных ситуациях. Знайте, что если вы введёте и запустите случайный пример, он может не скомпилироваться! Убедитесь, что вы прочитали окружающий текст, чтобы понять, не предназначен ли пример, который вы пытаетесь запустить, для демонстрации ошибки. Ferris также поможет вам различить код, который не предназначен для работы:

Ferris	Пояснения
	Этот код не компилируется!
	Этот код вызывает состояние «panic»!
	Этот блок содержит небезопасный код.
	Этот код ведёт себя не так, как предполагается.

В большинстве случаев мы приведём вас к правильной версии любого кода, который не компилируется.

Исходные коды

Файлы с исходным кодом, используемым в этой книге, можно найти на GitHub.

Источник