Фотоконкурс «Вики любит Землю»: загрузите фотографии памятников природы

Молдовы, помогите Википедии и получите замечательные призы!

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

[править | править код]
Материал из Википедии — свободной энциклопедии
Перейти к навигацииПерейти к поиску
У этого термина существуют и другие значения, см. Rust.

Rust

Семантик мультипарадигмальный: параллельное, функциона
а льное, императивное, структурное
программирование

Класс процедурный язык программирования[d], язык

языка функционального
программирования, мультипарадигмальный язык
программирования, императивный язык
программирования[d], язык системного
программирования[d], свободное и открытое
программное обеспечение, компилируемый язык
программирования и язык программирования

Тип компилируемый
исполнени
я
 Появился 7 июля 2010[11]
в

Автор Грэйдон Хор, разработчики проекта Rust

Разработч Mozilla[1], Грэйдон Хор[d][1][2] и Rust Foundation[d][3]

ик

Расширен .rs  или  .rlib

ие файлов

Выпуск  1.52.1 (10 мая 2021)[4][5]

Система статическая, строгая, с выводом типов,

типов номинальная, линейная,
опционально динамическая

Основные rustc
реализаци
и

Испытал Alef[d][12], C++, C#, Cyclone, Erlang, Haskell, Limbo, N
влияние ewsqueak[d], OCaml, Scheme, SML и Swift

Повлиял Swift, Crystal, Zig[6][7], Elm, Idris, Spark[8], Project

на Verona[9][10]

Лицензия Apache License 2.0[13] и лицензия MIT[13]

Сайт rust-lang.org (англ.)

ОС кроссплатформенность

 Медиафайлы на Викискладе

Rust (англ. rust — ржавчина, [rʌst]) — мультипарадигмальный компилируемый язык
программирования общего назначения,
сочетает парадигмы функционального и процедурного программирования с
объектной системой, основанной на типажах. Управление памятью
осуществляется через механизм «владения» с использованием аффинных типов[en]
[14]
, что позволяет обходиться без системы сборки мусора во время исполнения
программы. Rust гарантирует безопасную работу с памятью благодаря
встроенной в компилятор системе статической валидации ссылок (borrow checker).
Имеются средства, позволяющие использовать приёмы объектно-
ориентированного программирования[15].

Ключевые приоритеты языка: безопасность, скорость и параллелизм. Rust

пригоден для системного программирования, в частности, он рассматривается как
перспективный язык для разработки ядер операционных систем[14]. Rust
сопоставим по скорости и возможностям с C++/Си, однако даёт большую
безопасность при работе с памятью, что обеспечивается встроенными в язык
механизмами контроля ссылок. Производительности программ на Rust
способствует использование «абстракций с нулевой стоимостью»[16].

После нескольких лет активной разработки первая стабильная версия (1.0) вышла
15 мая 2015 года, после чего новые версии выходят раз в 6 недель[17]. Для версий
языка, вышедших после 1.0, заявлена обратная совместимость[18].

Разрабатывается с 2010-х годов сообществом Mozilla Research и финансируется

фондом Mozilla Foundation. С 2020 года планировалась передача
интеллектуальной собственности и процессов развития и финансирования языка
в организацию Rust Foundation[19]. 8 февраля 2021 года пять компаний-учредителей
(AWS, Huawei, Google, Microsoft и Mozilla) официально объявили о создании Rust
Foundation.[20][21]

С 2016 по 2020 год Rust занимает первое место в списке любимых языков («Most
loved programming languages») по версии ежегодного опроса разработчиков Stack
Overflow Developer Survey[22][23].

Содержание

 1История
 2Система типов
 3Управление памятью
 4Синтаксис
o 4.1Связывание имён
o 4.2Сопоставление с образцом (match)
o 4.3unsafe
 5Объектная система
 6Параллельные вычисления
 7Другие особенности
 8Пример
 9Сравнение с другими языками
 10Примечания
  11Литература
 12Ссылки

История[править | править код]
Работа над языком была начата сотрудником Mozilla Грэйдоном Хором в 2006
году. Автор дал проекту название Rust, по его словам связанное с грибами
семейства ржавчинные (англ. rust fungi)[24].

В 2009 году[25] компания Mozilla начала отдельно спонсировать разработку Rust.

Спустя год, язык был официально представлен на Mozilla Summit 2010[26].
Изначальный компилятор, реализованный на OCaml, был заменен на новый,
написанный на Rust и использующий LLVM для генерации машинного кода[27]; в
следующем году новый компилятор впервые успешно скомпилировал сам себя[28].

Первая официальная альфа-версия Rust (0.1) была выпущена в январе

2012 года[29].

В апреле 2013 года был запущен Servo — экспериментальный проект компании

Mozilla по разработке браузерного движка на Rust.[30]

Первая стабильная версия Rust (1.0) вышла в мае 2015 года. Программные

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

Система типов[править | править код]

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

Реализована поддержка единичных типов[en] данных — типов, которые имеют ровно

один экземпляр и не занимают места в памяти, примеры:

 пустой кортеж  () ;
 пустой массив (напр.  [u8; 0] );
 структура без полей (напр.  struct Foo );
 структура с единичными типами ( struct
Foo([u8; 0], ()) ).
Реализованы пустые типы[en] данных — типы, экземпляры которых не могут быть
созданы; реализованы в виде перечисляемых типов, не имеющих вариантов:  enum
Void {} .

Все типы данных в языке делятся на две основные группы: простые и типы
стандартной библиотеки.

Простые типы (типы постоянной длины, встроенные в сам язык) — числовой,

булев, символьный, массив, срез, строковый срез, кортеж, ссылка, указатель на
функцию. Часть простых типов является «машинной», то есть реализуются
непосредственно в современных процессорах, таковы числовой, булев и
символьный. Типы, предоставляемые стандартной библиотекой  std  (переменной
длины): вектор, строка, хеш-таблица и им подобные.

Числовые типы:

 целое (integer): i8, u8, i16, u16, i32, u32, i64, u64,

i128, u128, а также isize и usize, имеющие размер
указателя на данной платформе. u8 применяется
для «байтовых» значений. Примеры значений:  -
5i8 ,  0x400_u16 ,  0o100i16 ,  20_922_789_888u64 ,  b'
*'  (байтовый литерал),  b'\x1b' ,  42  (тип этого
значения будет выведен
автоматически),  0xfff_fc00usize
 Число с плавающей запятой (float). f32, f64.
Примеры:  3.14f32 ,  6.0221e23f64 ,  2. ,

Булев (bool):  true ,  false .

Символьный (char): тип, представляющий символ Unicode (внутреннее

представление данных как u32). Примеры значений:  '₽' ,  '\n' ,  '\x7f' ,  '\u{CA0}' ,

Указатель на функцию (function pointer): объекты-функции имеют тип,

определяемый их сигнатурой, то есть параметрами и возвращаемым значением.
Пример:  let f: fn(i32) -> i32 = plus_one;

Ссылка (разделяемое заимствование — shared borrow)  &T  (разделяемая, не

изменяемая, не владеющая ресурсом), вместо того, чтобы забирать владение
ресурсом, она его заимствует. Имена, которые заимствуют что-то, не освобождают
ресурс, когда они выходят из области видимости. Кроме того, имена-владельцы
переходят в заимствованное состояние.
Ссылка изменяемая (изменяемое заимствование — mutable borrow)  &mut T  (не
владеющая ресурсом). Позволяет изменять ресурс, который заимствуется.

Структуры (struct):

 структура си-подобная:  struct Color {red: u8,

green: u8, blue: u8}
 структура-кортеж:  struct Color (u8, u8, u8);
 структура — «единичное» значение:  struct
Electron;

Коллекции:

 Массив (array) [T; N] — последовательность

фиксированного размера N из однотипных (типа
T) элементов. Примеры:  [1, 2, 3] ,  [true;
10000] .
 Вектор (vec, vector) Vec<T>  —
динамический/расширяемый массив.
Примеры:  vec![0; 10]; ,  Vec::with_capacity(10)
 Срез (slice, view) &[T]  — это ссылка (или
«проекция») на другую структуру данных. Они
полезны, когда нужно обеспечить безопасный,
эффективный доступ к части массива без
копирования. Пример:  &a[1..4] ,
 Кортеж (tuple) (T1, T2, T3, …). Подобно структуре,
содержит произвольное количество разнотипных
полей, но поля безымянны, обращение к полям
возможно по индексу (t.0, t.1). Кортежи —
безымянные типы: кортежи с одинаковым
количеством и типами полей являются
совместимыми по типу. С помощью ключевого
слова type можно задать псевдоним, который,
однако, не задаёт нового типа. Пример:  ("Age",
22) ,  ("Europe",) ,
 Кортеж нулевой длины ((); пустой кортеж) часто
называют «единичным значением».
Соответственно, тип такого значения  —
«единичный тип». Если функция не возвращает
значения, то считается, что она возвращает ().
 Хеш-таблица «ключ — значение» (HashMap)
HashMap<T1, T2> — это структура данных,
 реализующая интерфейс ассоциативного
массива, а именно, она позволяет хранить пары
(ключ, значение) и выполнять три операции:
операцию добавления новой пары, операцию
поиска и операцию удаления пары по ключу.
Хеш-таблицы в Rust похожи на векторы, и хранят
свои значения не по индексу, а по ключу.
Пример:  HashMap::new();
 Хеш-таблица — множество (HashSet)
HashSet<T> — множество уникальных значений
типа T. Добавление и удаление элементов, а
также поиск элементов происходит быстрее, чем
в других коллекциях[каких?].
Строковые типы:

 Строка (String) (имеет внутреннее представление

данных в виде  Vec<u8> ) — тип, владеющий
содержимым. String представляет собой строку,
размещённую в куче. Эта строка расширяема, и
она гарантированно является корректной
последовательностью байтов с точки
зрения UTF-8. String обычно создаётся путём
преобразования из строкового среза с
использованием метода to_string.
Примеры:  "строковый
срез".to_string() ,  String::new() .
 «Строковый срез» (string slice, string literal) &str,
&'static str. Частный случай среза. Строковые
срезы имеют фиксированный размер и не могут
быть изменены. Они представляют собой ссылку
на последовательность байтов UTF-8.
Пример:  "строковый срез" . &'static str — строка,
введённая символами в коде самой
программы, — тот же строковый срез, только
статически размещённый (сохраняемый в
скомпилированной программе).
o «Сырой строковый срез» (или сырой
строковый литерал), в котором не
работают управляющие
последовательности:  r"\d{0,5}.*" .
o «Байтовая строка» &[u8] — строковый
литерал с префиксом «b»:  b"white" .
Перечисление (enum): каждый вариант в перечислении в Rust может быть также
связан с другими данными, благодаря чему перечисление называют также tagged
union или типом-суммой. Синтаксис для объявления вариантов схож с
синтаксисом для объявления структур: могут быть варианты без данных, варианты
с именованными данными и варианты с безымянными данными:

 вариант с «единичным» значением:  enum Day

{Sunday, Monday, Tuesday, Wednesday, Thursday,
Friday, Saturday}
 вариант с конкретным значением:  enum Foo {Bar
= 123,} .
 вариант — структура (именованные
данные):  enum Message {Quit, Move { x: i32, y:
i32 }} .
 вариант — кортежная структура (безымянные
данные):  enum Message {Quit, Size(i32)} .

Константы:

 const  — постоянные. Живут в течение всего

времени работы программы. А именно, у них
вообще нет определённого адреса в памяти. Это
потому, что они встраиваются (inline) в каждое
место, где есть их использование,
 static  — значение с возможностью изменения,
имеющее время жизни  'static . Похожи на
постоянные, но статические значения не
встраиваются в место их использования. Это
значит, что каждое значение существует в
единственном экземпляре, и у него есть
определённый адрес. Также может быть
изменяемым, при помощи ключевого слова  mut .
Изменения возможны только в  unsafe  блоках.

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

Управление памятью[править | править код]

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

Реализована так называемая Move-семантика: по умолчанию Rust «переносит»

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

let a = "объект с данными в куче".to_string();

// объект передан переменной b
// переменная a становится неинициализированной
let b = a;
// ошибка!
let c = a;
// данные объекта на стеке
let a = 55;
// копия объекта передана переменной b
let b = a;
// c = 55
let c = a;

Ещё одна особенность модели памяти — поддержка заимствований (borrow) с

возможностью изменения заимствованного объекта ( &mut ) и без таковой ( & ):
Лексически и семантически очень схожи со ссылками, но имеют специфику:
заимствование объекта сходно семантике «Либо много читателей, либо один
писатель» — объект можно передать в заимствование либо однократно с
возможностью изменения объекта, либо многократно без таковой; заимствования
можно перезаимствовать другому заемщику. В отличие от обычной семантики
«Либо много читателей, либо один писатель», применяется не в контексте
синхронизации потоков, а универсально. Контроль корректности заимствований
происходит во время компиляции и не порождает дополнительного исполнимого
кода (принцип абстракций с нулевой стоимостью). Компилятором
контролируется также соотношение времён жизни заимствований и самого
объекта — заимствования не могут жить дольше (выходить за пределы области
видимости) заимствованного объекта. Заимствования работают с любыми
данными независимо от их размещения (стек, локальная или обменная куча,
другие специальные расположения). Следует различать независимые понятия —
изменяемость собственно заимствования ( let mut b = &c ) и изменяемость
заимствованного объекта ( let b = &mut c ).
Упаковка (Box) — «умный» указатель, владеющий объектом в куче, уничтожает
объект и освобождает память при выходе из области видимости.

Ячейка (Cell, RefCell) реализует изменяемость содержимого при неизменяемости

самой ячейки.

Указатели со счётчиком ссылок ( Rc<T> ) и с атомарным счётчиком ссылок ( Arc<T> ):

Умные указатели с подсчётом ссылок, уничтожающие объект и освобождающие
память при обнулении счётчика. Arc реализует потокобезопасность для счётчика
ссылок (но не для самого объекта). Rc и Arc контролируют неизменяемый объект,
поэтому типичное их использование выглядит как  Rc<Cell<T>>  в однопоточной
программе и  Arc<Mutex<T>>  в многопоточной.

«Сырые» указатели неизменяемые ( *const T ) и изменяемые ( *mut T ): Указатели

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

Связывания неизменяемы по умолчанию, а чтобы объявить переменную

изменяемой, необходимо ключевое слово mut.

Примеры:

let x = 80; // связывание владельца x со значением 80

let mut y = 50; // изменяемое связывание
let z = &x; // неизменяемая ссылка на неизменяемое связывание
let w = &mut y; // неизменяемая ссылка на изменяемое связывание
let r = &mut y; // ошибка: нельзя создавать вторую ссылку на
изменяемое связывание

*w = 90 // y = 90
*z = 30 // ошибка: попытка изменения через ссылку на неизменяемое
связывание

let n = Box::new(42); // упаковка

let m = Rc::new(55); // счётчик ссылок
let data = Arc::new("test_string") // атомарный счётчик

Синтаксис[править | править код]
Синтаксис языка похож на Си и C++; язык регистро-зависимый, блоки кода
ограничиваются фигурными скобками; используются стандартные наименования
управляющих конструкций if, else, while, и for; комментарии также пишутся в С-
формате; имена модулей разделяются двумя символами двоеточия ( :: ).
Идентификаторы могут содержать латинские буквы, цифры и знак подчёркивания.
В строковых литералах допускается использование любых символов unicode в
кодировке UTF-8.
Набор операторов в Rust: арифметические ( *  — умножение,  /  — деление,  %  —
взятие остатка от деления,  +  — сложение,  -  — вычитание и унарный префиксный
оператор  -  для смены знака числа), битовые ( >> ,  << ,  & ,  |  и  ^ ), операторы
сравнения ( == ,  != ,  < ,  > ,  <= ,  >= ), логические ( &&  и  || ). Для приведения типов в
Rust используется бинарный оператор  as . Неявное приведение типов происходит
в очень небольшом наборе ситуаций[32].

Rust поддерживает макроопределения — средства подстановки с использованием

регулярных выражений, выполняющиеся во время этапа подготовки к компиляции,
более развитые и безопасные, чем в Си. Макроопределения (макрокоманды) —
это определяемые пользователем простые расширения синтаксиса, выполняемые
с помощью команды  macro_rules!  Макрокоманды определяются в том же стиле,
что и конструкция сопоставления с образцом. Признак макроса —
восклицательный знак в конце имени. Также поддерживаются так называемые
«процедурные» макроопределения[33], имеющие возможность исполнять
произвольный код во время компиляции.

Связывание имён[править | править код]

Ключевое слово  let  определяет связывание (локальную переменную).

let x: i32 = 5;

Данная запись обозначает: « x  — это связывание типа  i32  (32-битное целое) со

значением пять».

Сопоставление с образцом (match)[править | править код]

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

match x {
1 | 2 => println!("один или два"),
3 => println!("три"),
_ => println!("что угодно"),
}

Деструктуризация. При работе с составным типом данных, вроде struct, можно

разобрать его на части («деструктурировать») внутри шаблона:
 match origin {
Point { x, y } => println!("({},{})", x, y),
}

unsafe[править | править код]
В блоках и функциях, помеченных  unsafe  (англ. unsafe — небезопасный),
компилятор разрешает делать лишь пять дополнительных вещей:

 читать и обновлять
изменяемые статические ( static mut )
переменные;
 разыменовывать сырые указатели;
 вызывать небезопасные ( unsafe ) функции;
 реализовывать небезопасные типажи;
 Получать доступ к полям  union .

К  unsafe  приходится прибегать при создании низкоуровневых абстракций, в

частности — при разработке стандартной библиотеки Rust; обычный код
рекомендуется писать без  unsafe .

Объектная система[править | править код]

В Rust объектная система основана на типажах (traits) и структурах (structs).
Типажи определяют сигнатуры методов, которые должны быть реализованы для
каждого типа (чаще всего — структуры), реализующего типаж. Типаж может
содержать и реализации методов, принимаемые по умолчанию. Реализация
типажей для данной структуры, а также реализация собственных методов
структуры обозначается ключевым словом  impl . Язык содержит несколько
десятков встроенных типажей, большая часть которых используется
для перегрузки операторов, а некоторые имеют специальное значение.

Rust поддерживает аналогию наследования типажей — типаж может требовать от

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

Язык поддерживает обобщённые типы (generics). Помимо функций, обобщёнными

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

Параллельные вычисления[править | править код]

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

Определение и вызов асинхронных операций поддерживаются на уровне

синтаксиса языка: ключевое слово  async  определяет асинхронную функцию или
блок; обычный вызов такой функции возвращает объект с типажом  Future  —
дескриптор ленивой асинхронной операции[35]. Вызов  .await  позволяет одной
асинхронной операции ждать, пока не завершится другая асинхронная операция.
При этом реализация среды исполнения асинхронных операций не входит ни в
ядро языка, ни в стандартную библиотеку, а предоставляется сторонними
библиотеками[36].

Другие особенности[править | править код]

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

Система модулей: единица компиляции («крейт») может состоять из нескольких

модулей. Иерархия модулей, как правило, совпадает с иерархией каталогов и
файлов проекта. Модуль (как правило) является отдельным файлом, а также
является пространством имен и одним из средств управления видимостью
идентификаторов: в пределах модуля (и в подмодулях) «видны» все
идентификаторы, в вышестоящих модулях видны только публичные ( pub )
функции, типы, типажи, константы, подмодули, поля структур.

Автоматизированное тестирование: язык дает возможность реализовать

автоматизированные модульные тесты (юнит-тесты) прямо в тестируемом модуле
либо подмодуле. Тестовые методы при компиляции игнорируются и вызываются
только при тестировании. Интеграционные тесты реализуются как отдельные
крейты в каталоге  tests .
Автоматизированное документирование: средство rustdoc позволяет генерировать
HTML-документацию прямо из исходного кода. Документация в коде маркируется
тройным слешем ( /// Пример документации ), либо двойным с восклицательным
знаком, для документации модулей ( //! Пример документации модуля ).
Поддерживается язык разметки Markdown. В документацию может быть встроен
код, который является запускаемым (документационные тесты). Это позволяет, в
том числе, проверять актуальность документации при внесении изменений в
проект.

Система управления пакетами: менеджер пакетов cargo (являющийся также

основным инструментом создания, компиляции и тестирования проектов) с
помощью файла манифеста Cargo.toml[en] разрешает зависимости проекта
(импортируемые крейты), загружая их из репозитория crates.io.

Требования к идентификаторам: компилятор контролирует выполнение

соглашений об именовании переменных, типов, функций и так далее
(snake_case, UpperCamelCase, SCREAMING_SNAKE_CASE), а также
неиспользуемые идентификаторы; неиспользуемые идентификаторы
рекомендуется начинать со знака подчеркивания; есть определённые
рекомендации по именованию конструкторов, методов преобразования типов и др.
[37]

Пример[править | править код]
Hello, world!:

fn main() {
println!("Hello, world!");
}

Сравнение с другими языками[править | править код]

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

Примечания[править | править код]
↑ Показывать компактно

1. ↑ Перейти обратно:1 2 3 4 https://prev.rust-lang.org/id-ID/faq.html
2. ↑ Перейти обратно:1 2 https://jaxenter.com/mozillas-graydon-hoare-
working-on-rust-102672.html
3. ↑ Перейти обратно:1 2 https://foundation.rust-lang.org/posts/2021-
02-08-hello-world/
4. ↑ Announcing Rust 1.52.1
5. ↑ Release 1.52.1 — 2021.
6. ↑ https://ziglang.org
7. ↑ Язык программирования Zig / Хабр
8. ↑ [1710.07047] Safe Pointers in SPARK 2014
9. ↑ Microsoft opens up Rust-inspired Project Verona
programming language on GitHub. — «Microsoft recently
created a stir after revealing it was taking some ideas from the
popular Rust programming language to create a new
language for 'safe infrastructure programming' under the
banner Project Verona.». Дата обращения: 17 января 2020.
10. ↑ Microsoft создаёт новый язык программирования,
основанный на Rust / Хабр
11. ↑ Hoare  G. https://mail.mozilla.org/pipermail/rust-dev/2010-
July/000001.html (англ.) — 2010.
12. ↑ Appendix: Influences - The Rust Reference
13. ↑ Перейти обратно:1 2 https://github.com/rust-
lang/rust/blob/master/COPYRIGHT
14. ↑ Перейти обратно:1 2 Levy, Amit. The Case for Writing a Kernel in
Rust : [англ.] / Amit Levy, Bradford Campbell,
Branden Ghena … [et al.]// Proceedings of the 8th Asia-
Pacific Workshop on Systems. — N. Y. : ACM, 2017. — P. 1—
7. — (APSys '17). — ISBN 978-1-4503-5197-
3. — doi:10.1145/3124680.3124717.
15. ↑ Frequently Asked Questions // Design
Patterns (англ.) (недоступная ссылка). архивный сайт Rust. —
FAQ о языке Rust. — «Many things you can do in OO
languages you can do in Rust, but not everything, and not
always using the same abstraction you’re accustomed to. […]
There are ways of translating object-oriented concepts like
multiple inheritance to Rust, but as Rust is not object-oriented
the result of the translation may look substantially different
from its appearance in an OO language.». Дата обращения: 25
мая 2020. Архивировано 29 января 2018 года.
16. ↑ Ivo Balbaert. Rust Essentials. — Packt Publishing, May
2015. — ISBN 978-1-78528-576-9.
17. ↑ The Rust Core Team. Announcing Rust 1.0 (англ.). The Rust
Programming Language Blog (15 May 2015). Дата обращения:
18 августа 2015.
18. ↑ Road to Rust 1.0 - The Rust Programming Language Blog.
blog.rust-lang.org. Дата обращения: 11 января 2017.
19. ↑ Анонсировано создание независимой от Mozilla
организации Rust Foundation (рус.).
20. ↑ Rust Foundation (англ.). foundation.rust-lang.org. Дата
обращения: 18 февраля 2021.
21. ↑ Daniel Nazer. Mozilla Welcomes the Rust
Foundation (англ.). The Mozilla Blog. Дата обращения: 18
февраля 2021.
22. ↑ Stack Overflow Developer Survey 2019 (англ.). Stack
Overflow. — «For the fourth year in a row, Rust is the most
loved programming language among our respondents». Дата
обращения: 4 сентября 2019.
23. ↑ Stack Overflow Developer Survey 2020
24. ↑ Frequently Asked Questions // Why is the language called
Rust? (англ.). — Историческая версия официального FAQ о
языке Rust по состоянию на ноябрь 2015 года; в более
поздних версиях текста раздел об истории именования
языка исчез. — «As stated by Graydon Hoare, original
developer of the Rust language, the name "Rust" comes from
his personal interest in fungi, and because it evoked the
feeling he was looking for in a programming language
name.». Дата обращения: 1 декабря 2016.
25. ↑ Project FAQ (англ.). Официальный сайт Rust (2014). Дата
обращения: 17 апреля 2012.
26. ↑ Brendan Eich. Future Tense (англ.) (недоступная ссылка)
(29 April 2011). — «At Mozilla Summit 2010, we launched
Rust, a new programming language motivated by safety and
concurrency for parallel hardware, the “manycore” future
which is upon us.». Дата обращения: 17 апреля
2012. Архивировано 18 сентября 2012 года.
27. ↑ Graydon Hoare. Rust Progress (англ.) (недоступная ссылка)
(2 October 2010). Дата обращения: 17 апреля
2012. Архивировано18 сентября 2012 года.
28. ↑ Graydon Hoare. [rust-dev] stage1/rustc
builds (англ.) (20 April 2011). — «After that last change fixing
the logging scope context bug, looks like stage1/rustc builds.
Just shy of midnight :)». Дата обращения: 17 апреля 2012.
29. ↑ Brian Anderson. The Rust compiler 0.1 is unleashed (англ.).
Списки рассылки Mozilla (20 January 2012). Дата обращения:
22 сентября 2014.
30. ↑ Brendan Eich. Mozilla and Samsung Collaborate on Next
Generation Web Browser Engine (англ.). Официальный
блог Mozilla (3 April 2013). Дата обращения: 22 сентября 2014.
31. ↑ Announcing Rust 1.0.
32. ↑ В частности, поддерживается неявное приведение
ссылки к указателю; изменяемой ссылки (указателя) к
неизменяемой ссылке (указателю); объекта
определённого типа к объекту с типажом, реализованным
этим типом. Отсутствует неявное приведение чисел или
строк к булевому значению.
 33. ↑ Procedural Macros - The Rust Reference. doc.rust-
lang.org. Дата обращения: 19 августа 2020.
34. ↑ Михаил Панков. Есть ли ООП в
Rust?. rustycrate.ru(11 июня 2017). Дата обращения: 6 июня
2020.
35. ↑ Niko Matsakis. Async-await on stable Rust! (англ.)
(7 November 2019). Дата обращения: 6 июня 2020.
36. ↑ tokio::runtime (англ.) (13 May 2020). Дата обращения: 6 июня
2020.
37. ↑ Naming (англ.) (недоступная ссылка). Rust API
Guidelines. Дата обращения: 16 октября
2018. Архивировано 16 сентября 2018 года.

Литература[править | править код]
 Блэнди Дж., Орендорф Дж. Программирование
на языке Rust = Programming Rust. — ДМК Пресс,
2018. — 550 с. — ISBN 978-5-97060-236-2.
o Оригинал: Jim Blandy, Jason
Orendorff. Programming Rust. — O'Reilly
Media, March 2016. — ISBN 978-1-4919-
2721-2.
 Ivo Balbaert. Rust Essentials. — Packt Publishing,
May 2015. — ISBN 978-1-78528-576-9.

Ссылки[править | править код]
 rust-lang.org — официальный сайт языка
программирования Rust
 Центральный репозиторий библиотек,
написанных на Rust
 Ржавый ящик — русскоязычный сайт о языке
программирования Rust
 Rust Rosetta — реализации различных задач
программирования
 Язык программирования Rust (оригинал: The Rust
Programming Language).
 Rust на примерах (оригинал: Rust by Example).

[показать]
Проекты Mozilla
Категории: 
 Языки программирования по алфавиту
 Языки программирования, появившиеся в 2010 году
  Проекты Mozilla
 Rust (язык программирования)
 Функциональные языки программирования
 Процедурные языки программирования
 Многопоточные языки программирования
Навигация
 Вы не представились системе
 Обсуждение
 Вклад
 Создать учётную запись
 Войти
 Статья
 Обсуждение
 Читать
 Править
 Править код
 История
Поиск
????? ???????

 Заглавная страница
 Рубрикация
 Указатель А — Я
 Избранные статьи
 Случайная страница
 Текущие события
Участие
 Сообщить об ошибке
 Сообщество
 Форум
 Свежие правки
 Новые страницы
 Справка
 Пожертвовать
Инструменты
 Ссылки сюда
 Связанные правки
 Служебные страницы
 Постоянная ссылка
 Сведения о странице
 Цитировать страницу
Печать/экспорт
  Создать книгу
 Скачать как PDF
 Версия для печати
В других проектах
 Викисклад
 Викиновости
 Элемент Викиданных
На других языках
 ‫العربية‬
 English
 Español
 Bahasa Indonesia
 Bahasa Melayu
 Português
 Română
 Українська
 中文
Ещё 27
Править ссылки
 Эта страница в последний раз была отредактирована 19 апреля 2021 в 05:14.
 Текст доступен по лицензии Creative Commons Attribution-ShareAlike; в отдельных случаях могут действовать
дополнительные условия. Подробнее см. Условия использования.
Wikipedia® — зарегистрированный товарный знак некоммерческой организации Wikimedia Foundation, Inc.
 Политика конфиденциальности

 Описание Википедии

 Отказ от ответственности

 Свяжитесь с нами

 Мобильная версия

 Разработчики

 Статистика

 Заявление о куки