Руст (язык программирования)

Ржавчина

Парадигмы	Параллельно функциональный универсальный императив структурированный
Разработчик	Фонд ржавчины
Впервые появился	15 мая 2015 г ( 15 мая 2015 )
Стабильная версия	1.78.0  / 2 мая 2024 г ( 2 мая 2024 г. )
Дисциплина набора текста	Аффинный предполагаемый номинальный статический сильный
Язык реализации	Ржавчина
Платформа	Кросс-платформенный
ТЫ	Кросс-платформенный
Лицензия	Массачусетский технологический институт и Apache 2.0
Расширения имен файлов	.rs, .rlib
Веб-сайт	www .отдых .org
Под влиянием
Алеф С# С++ Циклон Вяз Эрланг Хаскелл Лимбо газеты OCaml Рубин Схема Стандартный ML Быстрый
Под влиянием
Идрис Проект Верона Искра Быстрый V Зиг

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

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

Разработчик программного обеспечения Грейдон Хоар создал Rust как личный проект во время работы в Mozilla Research в 2006 году. Mozilla официально спонсировала проект в 2009 году. В годы, прошедшие после выхода первого стабильного выпуска в мае 2015 года, Rust был принят такими компаниями, как Amazon , Discord , Dropbox , Google ( Alphabet ), Meta и Microsoft . В декабре 2022 года он стал первым языком, кроме C и ассемблера , который поддерживался при разработке ядра Linux .

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

История

Штаб-квартира Mozilla Foundation в Маунтин-Вью, Калифорния

(

Rust зародился как личный проект в 2006 году сотрудника Mozilla Research Грейдона Хоара. Mozilla начала спонсировать проект в 2009 году в рамках продолжающейся разработки экспериментального браузерного движка под названием Servo . который был официально анонсирован Mozilla в 2010 году. На систему памяти и владения Rust повлияло управление памятью на основе регионов в таких языках, как Cyclone и ML Kit.

Примерно в то же время работа перешла от первоначального компилятора , написанного на OCaml , к автономному компилятору на основе LLVM , написанному на Rust. Новый компилятор Rust успешно скомпилировался в 2011 году. Осенью 2011 года был разработан логотип Rust на основе велосипедной звезды .

Эволюция (2012–2020

Rust Система типов претерпела значительные изменения между версиями 0.2, 0.3 и 0.4. В версии 0.2, вышедшей в марте 2012 года, классы . впервые были представлены Четыре месяца спустя в версии 0.3 были добавлены деструкторы и полиморфизм за счет использования интерфейсов. В октябре 2012 года вышла версия 0.4, в которой были добавлены черты как средство наследования . Интерфейсы были объединены с особенностями и удалены как отдельная функция; а классы были заменены комбинацией реализаций и структурированных типов .

В начале 2010-х годов управление памятью через систему владения постепенно консолидировалось, чтобы предотвратить ошибки памяти. Rust К 2013 году сборщик мусора был удален, а правила владения остались в силе.

В январе 2014 года главный редактор Dr. Dobb's Journal Эндрю Бинсток прокомментировал шансы Rust стать конкурентом C++ наряду с D , Go и Nim (тогда Nimrod). По словам Бинстока, хотя Rust «широко считался удивительно элегантным языком», его внедрение замедлилось, поскольку он радикально менялся от версии к версии. Первая стабильная версия Rust 1.0 вышла 15 мая 2015 года.

Разработка браузерного движка Servo продолжалась параллельно с ростом Rust. В сентябре 2017 года был выпущен Firefox 57 как первая версия, включающая компоненты Servo, в проекте под названием « Firefox Quantum ».

Увольнения в Mozilla и Rust Foundation (2020 –

В августе 2020 года Mozilla уволила 250 из 1000 своих сотрудников по всему миру в рамках корпоративной реструктуризации, вызванной пандемией COVID-19 . Команда Servo была расформирована. Мероприятие вызвало обеспокоенность по поводу будущего Rust, поскольку некоторые члены команды активно участвовали в разработке Rust. На следующей неделе команда Rust Core признала серьезные последствия увольнений и объявила, что планы по созданию фонда Rust находятся в стадии реализации. Первой целью фонда будет стать владельцем всех товарных знаков и доменных имен и взять на себя финансовую ответственность за их расходы.

создании Rust Foundation ) объявили о 8 февраля 2021 года пять компаний-основателей ( AWS , Huawei , Google , Microsoft и Mozilla . В сообщении в блоге , опубликованном 6 апреля 2021 года, Google объявил о поддержке Rust в рамках проекта Android Open Source Project в качестве альтернативы C/C++.

22 ноября 2021 года группа модераторов, отвечавшая за соблюдение стандартов сообщества и Кодекса поведения, объявила о своей отставке «в знак протеста против того, что основная команда считает себя безотчетной ни перед кем, кроме себя». В мае 2022 года команда Rust Core, другие ведущие программисты и некоторые члены правления Rust Foundation реализовали реформы управления в ответ на инцидент.

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

Синтаксис и особенности

Rust Синтаксис аналогичен синтаксису C и C++. хотя на многие его функции повлияли языки функционального программирования, такие как OCaml . Хоар описал Rust как ориентированный на «разочарованных разработчиков C++» и подчеркнул такие функции, как безопасность, контроль структуры памяти и параллелизм . Безопасность в Rust включает в себя гарантии безопасности памяти, безопасности типов и отсутствия гонок за данными.

Программа «Привет, мир»

Ниже находится надпись «Hello, World!» программа на Rust. fn Ключевое слово обозначает функцию , а println! макрос выводит сообщение на стандартный вывод . Операторы в Rust разделяются точкой с запятой .

fn   main  ()   { 
     println!   (  "Привет, мир!"  ); 
  } 

Ключевые слова и поток управления

В Rust блоки кода разделяются фигурными скобками , а поток управления реализуется с помощью ключевых слов, включая if, else, while, и for. Сопоставление с образцом можно выполнить с помощью match ключевое слово. В примерах ниже пояснения даются в комментариях , которые начинаются с //.

fn   main  ()   { 
     // Определение изменяемой переменной с помощью 'let mut' 
     // Использование макроса vec!   чтобы создать вектор, 
     пусть   mut   значения   =   vec!   [  1  ,   2  ,   3  ,   4  ]; 

      для   значения   в   &  значений   { 
         println!   (  "значение = {}"  ,   значение  ); 
      } 

     если   значения  .   len  ()   >   5   { 
         println!   (  «Список длиннее пяти элементов»  ); 
      } 

     шаблону 
     соответствия   // Значения  .   лен  ()   { 
         0   =>   println!   (  «Пусто»  ), 
         1   =>   println!   (  «Одно значение»  ), 
         // при сопоставлении с образцом можно использовать диапазоны целых чисел 
         2  ..=  10   =>   println!   (  «От двух до десяти значений»  ), 
         11   =>   println!   (  "Одиннадцать значений"  ), 
         // Шаблон `_` называется "подстановочным знаком", он соответствует любому значению 
         _   =>   println!   (  «Много значений»  ), 
     }; 

      // цикл while с предикатом и сопоставлением с образцом с использованием let 
     while   let   Some  (  value  )   =   values  .   поп  ()   { 
         println!   (  "значение = {значение}"  );    // использование фигурных скобок для форматирования локальной переменной 
     } 
 } 

Блоки выражений

Rust ориентирован на выражения , причем почти каждая часть тела функции является выражением , включая операторы потока управления. Обычный ifвыражение используется вместо C. троичного условного выражения Поскольку возвраты являются неявными, функция не обязательно должна заканчиваться returnвыражение; используется значение последнего выражения в функции если точка с запятой опущена, в качестве возвращаемого значения , как видно из следующей рекурсивной реализации функции факториала :

fn   факториал  (  i  :  u64  )   ->  u64   { 
     if   i   ==   0   { 
         1 
     }   else   { 
         i   *   факториал  (  i   -   1  ) 
     } 
 } 

Следующая итеративная реализация использует ..= оператор для создания включающего диапазона:

fn   факториал  (  я  :  u64  )   ->  u64   { 
     (  2  ..=  i  ).   продукт  () 
 } 

Замыкания

Этот раздел представляет собой отрывок из анонимной функции § Rust . [ редактировать ]

В Rust анонимные функции называются замыканиями. Они определяются с использованием следующего синтаксиса:

|<  параметр  -  имя  >  :  <  тип  >|    ->  <  возврат  -  тип  >   {   <  тело  >   }; 

Например:

пусть   ж   =   |   х  :  i32  |    ->  i32   {   х   *   2   }; 

Однако с помощью вывода типа компилятор может определить тип каждого параметра и тип возвращаемого значения, поэтому приведенную выше форму можно записать как:

пусть   ж   =   |   х  |    {   х   *   2   }; 

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

пусть   ж   =   |   х  |    х   *   2  ; 

Замыкания без входного параметра записываются так:

пусть   f   =   ||    распечататьлн!   (  "Привет, мир!"  ); 

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

// Функция, которая принимает указатель функции в качестве аргумента и вызывает ее 
 // со значением `5`. 
  fn   apply  (  f  :  fn  (  i32  )   ->  i32  )   ->  i32   { 
     // Нет точки с запятой, чтобы указать неявный возврат 
     f  (  5  ) 
 } 

 fn   main  ()   { 
     // Определение замыкания 
     let   f   =   |   х  |    х   *   2  ; 

      распечататьлн!   (  "{}"  ,   применить  (  f  ));     // 10 
     println!   (  "{}"  ,   f  (  5  ));         // 10 
 } 

Однако для описания того, как фиксируются значения в теле замыкания, могут потребоваться сложные правила. Они реализуются с помощью Fn, FnMut, и FnOnce черты:

• Fn: замыкание фиксируется по ссылке ( &T). Они используются для функций, которые все еще можно вызывать, если у них есть только ссылочный доступ (с &) к окружающей среде.
• FnMut: замыкание фиксируется по изменяемой ссылке ( &mut T). Они используются для функций, которые можно вызывать, если у них есть доступ к изменяемым ссылкам (с &mut) к окружающей среде.
• FnOnce: замыкание захватывает по значению ( T). Они используются для функций, которые вызываются только один раз.

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

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

// Функция, которая принимает значение типа F (который определяется как 
 // универсальный тип, реализующий признак `Fn`, например замыкание) 
 // и вызывает его со значением `5`. 
  fn   apply_by_ref  <  F  >  (  f  :  F  )   ->  i32 
     где   F  :  Fn  (  i32  )   ->  i32 
 { 
     f  (  5  ) 
 } 

 fn   main  ()   { 
     let   f   =   |   х  |    { 
         печать!   (  «Я получил значение: {}»  ,   x  ); 
          х   *   2 
     }; 
    
      // Применяет функцию перед печатью возвращаемого значения 
     println!   (  "5 * 2 = {}"  ,   apply_by_ref  (  f  )); 
  } 

 // ~~ Вывод программы ~~ 
 // Я получил значение: 5 
 // 5 * 2 = 10 

Предыдущее определение функции также можно для удобства сократить следующим образом:

fn   apply_by_ref  (  f  :  impl   Fn  (  i32  )   ->  i32  )   ->  i32   { 
     f  (  5  ) 
 } 

Типы

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

Целочисленный тип по умолчанию: i32, а тип с плавающей запятой по умолчанию — f64. Если тип буквального числа не указан явно, он либо выводится из контекста, либо используется тип по умолчанию.

Примитивные типы

Rust Краткое описание примитивных типов

Тип	Описание	Примеры
bool	Логическое значение	true false
u8	Беззнаковое 8-битное целое число ( байт )	255u8 b'W' ( ASCII ) байт в кодировке
i8 i16 i32 i64 i128	Целые числа со знаком , до 128 бит.	7 7i128
u16 u32 u64 u128	Целые числа без знака , до 128 бит.	14 14u128
usize isize	Целые числа размером с указатель (размер зависит от платформы )	14usize -2isize
f32 f64	Числа с плавающей запятой	-3f32
char	Скалярное значение UTF-32 (занимает 4 байта) Кодовый знак Юникода , который не является суррогатным	'a' '语' '🦀' ( Emoji ) '\u{200D}' (Escape Unicode, соединение нулевой ширины )
str	Срез строки в кодировке UTF-8 , примитивный тип строки. Обычно его видят в заимствованной форме, &str. Это также тип строковых литералов, &'static str	"Hello" "3" "🦀🦀🦀"
[T; N]	Массив – совокупность N объектов одного типа T, хранящихся в непрерывной памяти.	[2, 4, 6] [0; 100] b"Hello"
[T]	Срез — представление непрерывной последовательности динамического размера.	[1, 2, 3, 4, 5][..i] "Hello, world!".as_bytes() let v = vec![1, 2, 3]; v.as_slice()
(T, U, ..)	Кортеж - конечная гетерогенная последовательность.	() (Пустой кортеж, тип юнита в Rust) (5,) ( (5) анализируется как целое число) ("Age", 10) (1, true, "Name")
!	Никогда не вводите (недоступное значение)	let x = { return 123 };

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

Краткое описание типов Rust в стандартной библиотеке

Тип	Описание	Примеры
String	Строки в кодировке UTF-8 (динамические)	String::new() String::from("Hello") "🦀🦀🦀".to_string()
OsStr OsString	Собственные строки платформы (заимствованный и динамичный )	OsStr::new("Hello") OsString::from("world")
Path PathBuf	Пути (заимствованные и динамичный )	Path::new("./path/to") PathBuf::from(r"C:.\path\to")
CStr CString	C -совместимые строки с нулевым завершением (заимствованные и динамичный )	c"Hello" CStr::from_bytes_with_nul(b"Hello\0").unwrap() CString::new("world").unwrap()
Vec<T>	Динамические массивы	Vec::new() vec![1, 2, 3, 4, 5]
Option<T>	Тип опции	None Some(3) Some("hello")
Result<T, E>	Обработка ошибок с использованием типа результата	Ok(3) Err("something went wrong")
Box<T>	Указатель на значение, выделенное в куче . Аналогично std::unique_ptr в C++ .	пусть в штучной упаковке : Box < u8 > = Box :: new ( 5 ); пусть val : u8 = * в штучной упаковке ;
Rc<T>	подсчета ссылок Указатель	пусть пять = Rc :: new ( 5 ); пусть также_пять = пять . клон ();
Arc<T>	Атомный , потокобезопасный указатель подсчета ссылок	пусть foo = Arc :: new ( vec! [ 1.0 , 2.0 ]); пусть а = фу . клон (); // можно отправить в другой поток
Cell<T>	Изменяемая ячейка памяти	пусть c = Cell :: new ( 5 ); в . набор ( 10 );
Mutex<T>	Блокировка мьютекса для общих данных, содержащихся внутри.	пусть мьютекс = Мьютекс :: new ( 0_ u32 ); пусть _guard = мьютекс . замок ();
RwLock<T>	Блокировка чтения и записи	let lock = RwLock :: new ( 5 ); пусть r1 = блокировка . читать (). развернуть ();
Condvar	Условный монитор для общих данных	let ( lock , cvar ) = ( Mutex :: new ( true ), Condvar :: new ()); // Пока значение внутри Mutex<bool> равно true, мы ждем. пусть _guard = cvar . wait_ while ( lock . lock (). unwrap (), | в ожидании | { * в ожидании }). развернуть ();
Duration	Тип, представляющий промежуток времени	Продолжительность :: from_millis ( 1 ) // 1 мс
HashMap<K, V>	Хеш-таблица	пусть mut player_stats = HashMap :: new (); player_stats . вставить ( "повреждение" , 1 ); player_stats . запись ( «здоровье» ). или_вставить ( 100 );
BTreeMap<K, V>	B-дерево	let mut sun_distance = BTreeMap :: from ([ ( "Меркурий" , 0.4 ), ( "Венера" , 0.7 ), ]); солнечное_дистанция . запись ( «Земля» ). или_вставить ( 1.0 );

Option значения обрабатываются с использованием синтаксического сахара , такого как if let конструкция для доступа к внутреннему значению (в данном случае к строке):

fn   main  ()   { 
     let   name1  :  Option  <&  str  >   =   None  ; 
      // В этом случае ничего не будет распечатано, 
     если   let   Some  (  name  )   =   name1   { 
         println!   (  "{имя}"  ); 
      } 

     let   name2  :  Option  <&  str  >   =   Some  (  "Мэтью"  ); 
      // В этом случае слово «Мэтью» будет напечатано, 
     если   let   Some  (  name  )   =   name2   { 
         println!   (  "{имя}"  ); 
      } 
 } 

Указатели

примитивов Rust указателей и ссылочных Краткое описание типов

Тип	Описание	Примеры
&T &mut T	Ссылки (неизменяемые и изменяемые)	let x_ref = &x; let x_ref = &mut x;
Option<&T> Option<&mut T>	Ссылка на вариант Возможно, нулевая ссылка	None let x_ref = Some(&x); let x_ref = Some(&mut x);
Box<T> Option<Box<T>>	Указатель на значение, выделенное в куче (или, возможно, нулевой указатель, если он заключен в опцию)	let boxed = Box::new(0); let boxed = Some(Box::new("Hello World"));
*const T *mut T	Необработанные указатели (неизменяемые и изменяемые) Возможно, ноль ; unsafe разыменовать ​	let x_ptr = &x as *const T; let x_ptr = &mut x as *mut T;

Rust не использует нулевые указатели для обозначения отсутствия данных, так как это может привести к нулевому разыменованию . Соответственно, основные & и &mutссылки гарантированно не будут нулевыми. Вместо этого Rust использует Option для этой цели: Some(T) указывает, что значение присутствует, и None аналогичен нулевому указателю. Option реализует «оптимизацию нулевого указателя», избегая любых пространственных издержек для типов, которые не могут иметь нулевое значение (ссылки или NonZero типы, например).

В отличие от ссылок, типы необработанных указателей *const и *mutможет быть нулевым; однако их невозможно разыменовать, если код явно не объявлен небезопасным с помощью unsafeблокировать. В отличие от разыменования, создание необработанных указателей разрешено внутри безопасного кода Rust.

Пользовательские типы

Пользовательские типы создаются с помощью struct или enumключевые слова. struct Ключевое слово используется для обозначения типа записи , который группирует несколько связанных значений. enums может принимать различные варианты во время выполнения, а его возможности аналогичны алгебраическим типам данных, встречающимся в функциональных языках программирования. И структуры, и перечисления могут содержать поля разных типов. Альтернативные имена для одного и того же типа можно определить с помощью type ключевое слово.

The implКлючевое слово может определять методы для определяемого пользователем типа. Данные и функции определяются отдельно. Реализации выполняют роль, аналогичную роли классов в других языках.

Преобразование типов

Этот раздел представляет собой отрывок из Преобразование типов § Rust . [ редактировать ]

Rust не обеспечивает неявного преобразования типов (принуждения) между примитивными типами. Но явное преобразование типов (приведение типов) можно выполнить с помощью as ключевое слово.

пусть   х   =   1000  ; 
  распечататьлн!   (  "1000 как u16: {}"  ,   x   как   u16  ); 

Право собственности и срок службы

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

fn   print_string  (  s  :  String  )   { 
     println!   (  "{}"  ,   с  ); 
  } 

 fn   main  ()   { 
     let   s   =   String  ::  from  (  «Hello, World»  ); 
      print_string  (  ы  );    // s, использованные print_string 
     // s были перемещены, поэтому их больше нельзя использовать 
     // другой print_string(s);   приведет к ошибке компиляции 
 } 

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

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

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

fn   main  ()   { 
     let   x   =   5  ;                                 // ------------------+- Время жизни 'a 
                                             // | 
      пусть   г   =   &  х  ;                                // --+-- Время жизни 'b | 
                                              // |   | 
      распечататьлн!   (  "р: {}"  ,   р  );                      // |   | 
                                              // |   | 
                                              // -+ | 
  }                                             // ------------------+ 

Средство проверки заимствований в компиляторе Rust использует время жизни, чтобы гарантировать, что значения контрольных точек остаются действительными. В приведенном выше примере сохранение ссылки на переменную x к r действителен как переменная x имеет более длительный срок службы( 'a), чем переменная r ( 'b). Однако, когда x имеет более короткий срок службы, программа проверки заимствований отклонит программу:

fn   main  ()   { 
     let   r  ;                                     // ------------------+- Время жизни 'a 
                                             // | 
      {                                         // | 
          пусть   х   =   5  ;                             // --+-- Время жизни 'b | 
          р   =   &  х  ;                                // |   | 
      }                                         // -|   | 
                                              // | 
      распечататьлн!   (  "р: {}"  ,   р  );                      // | 
  }                                             // ------------------+ 

Поскольку время жизни ссылочной переменной ( 'b) короче времени жизни переменной, содержащей ссылку ( 'a), ошибки проверки заимствований, предотвращающие x от использования за пределами своей области применения.

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

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

используйте   std  ::  collections  ::  HashMap  ; 

  // Эта структура имеет один параметр времени жизни, 'src.   Имя используется только в определении структуры. 
  #[derive(Debug)] 
 struct   Config  <'  src  >   { 
     hostname  :  &  '  src   str  , 
     username  :  &  '  src   str  , 
 } 

 // Эта функция также имеет параметр времени жизни 'cfg.   'cfg прикрепляется к параметру "config", который 
 // устанавливает, что данные в "config" живут, по крайней мере, в течение срока жизни 'cfg. 
  // Возвращенная структура также использует 'cfg на протяжении всего своего существования, поэтому она может существовать не более, чем 'cfg. 
  fn   parse_config  <'  cfg  >  (  config  :  &  '  cfg   str  )   ->  Config  <'  cfg  >   { 
     let   key_values  ​​:  HashMap  <  _  ,   _  >   =   config 
         .   линии  () 
         .   фильтр  (  |  линия  |   !  строка  .  начинается_с  (  '#'  )) 
         .   filter_map  (  |  линия  |   линия  .  Split_once  (  '='  )) 
         .   карта  (  |  (  ключ  ,   значение  )  |   (  ключ  .  обрезка  ( ),   значение  .  обрезка  ())) 
         .   собирать  (); 
      Config   { 
         имя_хоста  :  значения_ключа  [  "имя_хоста]  ], 
         имя пользователя  :  значения_ключей  [  "имя_пользователя"  ], 
     } 
 } 

 fn   main  ()   { 
     let   config   =   parse_config  ( 
         r#"hostname = foobar 
 username=barfoo"#  , 
     ); 
      распечататьлн!   (  "Разобранная конфигурация: {:#?}"  ,   config  ); 
  } 

Презентация по Rust Эмили Данэм из конференция команды Mozilla Rust ( linux.conf.au , Хобарт, 2017 г.)

Безопасность памяти

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

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

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

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

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

Полиморфизм

Дженерики

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

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

используйте   std  ::  ops  ::  Add  ; 

  // sum — это универсальная функция с одним параметром типа T 
 fn   sum  <  T  >  (  num1  :  T  ,   num2  :  T  )   ->  T 
 где   
     T  :  Add  <  Output   =   T  >  ,    // T должен реализовать признак Add, где сложение возвращает еще один T 
 { 
     num1   +   num2    // num1 + num2 — это синтаксический сахар для num1.add(num2), предоставляемый свойством Add 
 } 

 fn   main  ()   { 
     let   result1   =   sum  (  10  ,   20  ); 
      распечататьлн!   (  "Сумма: {}"  ,   результат1  );    // Сумма: 30 

     let   result2   =   sum  (  10.23  ,   20.45  ); 
      распечататьлн!   (  "Сумма: {}"  ,   результат2  );    // Сумма: 30,68 
 } 

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

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

Черты

Система типов Rust поддерживает механизм, называемый типажами, вдохновленный классами типов в языке Haskell . определить общее поведение между различными типами. Например, Addчерта может быть реализована для чисел с плавающей запятой и целых чисел, которые можно добавить; и Display или Debugчерты могут быть реализованы для любого типа, который можно преобразовать в строку. Черты могут использоваться для обеспечения набора общего поведения для разных типов без знания фактического типа. Эта возможность известна как специальный полиморфизм .

Универсальные функции могут ограничивать универсальный тип для реализации определенного признака или признаков; например, add_one функции может потребоваться тип для реализации Add. Это означает, что универсальную функцию можно проверить по типу сразу после ее определения. Реализация дженериков аналогична типичной реализации шаблонов C++: для каждого экземпляра создается отдельная копия кода. Это называется мономорфизацией и контрастирует со схемой стирания типов , обычно используемой в Java и Haskell. Стирание типа также доступно по ключевому слову dyn (сокращение от динамического). Поскольку мономорфизация дублирует код для каждого используемого типа, это может привести к более оптимизированному коду для конкретных случаев использования, но время компиляции и размер выходного двоичного файла также увеличиваются.

Помимо определения методов для определяемого пользователем типа, impl Ключевое слово может использоваться для реализации признака типа. При реализации трейты могут предоставлять дополнительные производные методы. Например, черта Iterator требует, чтобы nextметод должен быть определен для типа. Однажды next метод определен, признак может предоставлять общие функциональные вспомогательные методы для итератора, такие как map или filter.

Объекты черт

Черты Rust реализованы с использованием статической диспетчеризации , что означает, что тип всех значений известен во время компиляции; однако Rust также использует функцию, известную как объекты-характеристики, для выполнения динамической отправки (также известной как утиная типизация ). Динамически отправляемые объекты свойств объявляются с использованием синтаксиса dyn Tr где Trэто черта. Объекты признаков имеют динамический размер, поэтому их необходимо поместить за указателем, например Box. В следующем примере создается список объектов, каждый из которых можно распечатать с помощью Display черта:

используйте   std  ::  fmt  ::  Display  ; 

  let   v  :  Vec  <  Box  <  dyn   Display  >>   =   vec!   [ 
     Коробка  ::  новый  (  3  ), 
     Коробка  ::  новый  (  5.0  ), 
     Коробка  ::  новый  (  «привет»  ), 
 ]; 

  для   x   в   v   { 
     println!   (  "{Икс}"  ); 
  } 

Если элемент в списке не реализует Display черта, это вызовет ошибку времени компиляции.

Итераторы

Циклы for в Rust работают в функциональном стиле как операции над типом итератора . Например, в цикле

для   х   в   0  ..  100   { 
    f  (  x  ); 
  } 

0..100 это значение типа Range которая реализует Iteratorчерта; код применяет функцию fдля каждого элемента, возвращаемого итератором. Итераторы можно комбинировать с функциями над итераторами, например map, filter, и sum. Например, следующая команда суммирует все числа от 1 до 100, кратные 3:

(  1  ..=  100  ).   фильтр  (  |&  x  |   x   %   3   ==   0  ).   сумма  () 

Макросы

Язык Rust можно расширить с помощью макросов.

Декларативные макросы

Декларативный макрос (также называемый «макросом по примеру») — это макрос, который использует сопоставление с образцом для определения своего расширения.

Процедурные макросы

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

Процедурные макросы бывают трех видов:

• Функциональные макросы custom!(...)
• Получение макросов #[derive(CustomDerive)]
• Макросы атрибутов #[custom_attribute]

The println!макрос является примером функционального макроса. serde_derive макрос предоставляет широко используемую библиотеку для генерации кода для чтения и записи данных во многих форматах, таких как JSON . Макросы атрибутов обычно используются для языковых привязок, таких как extendr библиотека для привязок Rust R. к

Следующий код показывает использование Serialize, Deserialize, и Debug-производные процедурные макросы реализовать чтение и запись JSON, а также возможность форматировать структуру для отладки.

UML -диаграмма , изображающая структуру Rust с именем Point.

используйте   serde_json  ::  {  Сериализация  ,   Десериализация  }; 

  #[derive(Serialize, Deserialize, Debug)] 
 struct   Point   { 
     x  :  i32  , 
     y  :  i32  , 
 } 

 fn   main  ()   { 
     let   point   =   Point   {   x  :  1  ,   y  :  2   }; 

      let   сериализованный   =   serde_json  ::  to_string  (  &  point  ).   развернуть  (); 
      распечататьлн!   (  "сериализованный = {}"  ,   сериализованный  ); 

      пусть   десериализовано  :  Point   =   serde_json  ::  from_str  (  &  сериализовано  ).   развернуть  (); 
      распечататьлн!   (  "десериализован = {:?}"  ,   десериализовано  ); 
  } 

Этот раздел представляет собой отрывок из функции Variadic § в Rust . [ редактировать ]

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

макро_правила!    вычислить   { 
     // Шаблон для одного `eval` 
     (  eval   $e  :  expr  )   =>   {{ 
         { 
             let   val  :  usize   =   $e  ;    // Заставляем типы быть целыми числами 
             println!   (  "{} = {}"  ,   stringify!  {  $e  },   val  ); 
          } 
     }}; 

      // Рекурсивно разложить несколько `eval` 
     (  eval   $e  :  expr  ,   $(  eval   $es  :  expr  ),  +  )   =>   {{ 
         Calculation  !    {   eval   $e   } 
         вычислить  !    {   $(  оценка   $es  ),  +   } 
     }}; 
  } 

 fn   main  ()   { 
     вычислить  !    {   // Смотри, ма!   Вариатическое `вычислить!`! 
          оценка   1   +   2  , 
         оценка   3   +   4  , 
         оценка   (  2   *   3  )   +   1 
     } 
 } 

Rust может взаимодействовать с вариативной системой C через c_variadicпереключатель функций. Как и другие интерфейсы C, система считается unsafe к Русту.

Интерфейс с C и C++

В Rust есть интерфейс внешних функций (FFI), который можно использовать как для вызова кода, написанного на таких языках, как C , из Rust, так и для вызова кода Rust с этих языков. По состоянию на 2024 год существует внешняя библиотека CXX для вызова C++ или из него. Rust и C различаются тем, как они размещают структуры в памяти, поэтому структурам Rust можно присвоить #[repr(C)] атрибут, обеспечивающий тот же макет, что и эквивалентная структура C.

Экосистема

Компиляция программы Rust с помощью Cargo

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

Компилятор

Компилятор Rust назван rustcи переводит код Rust в язык низкого уровня, называемый промежуточным представлением LLVM (LLVM IR). Затем LLVM вызывается как подкомпонент для перевода IR-кода в машинный код . Затем компоновщик . используется для объединения нескольких ящиков в один исполняемый или двоичный файл

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

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

Стандартная библиотека Rust определяет и реализует множество широко используемых пользовательских типов данных, включая основные структуры данных, такие как Vec, Option, и HashMap, а также типы интеллектуальных указателей . Rust также предоставляет возможность исключить большую часть стандартной библиотеки с помощью атрибута #![no_std]; это позволяет приложениям, таким как встроенные устройства, удалять код зависимостей или предоставлять свои собственные основные структуры данных. Внутри стандартная библиотека разделена на три части: core, alloc, и std, где std и alloc исключены #![no_std].

Скриншот crates.io в июне 2022 г.

Должность

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

По умолчанию Cargo получает свои зависимости из пользовательского реестра crates.io , но в качестве зависимостей также можно указать репозитории и ящики Git в локальной файловой системе, а также другие внешние источники.

Рустфмт

Rustfmt — форматировщик кода для Rust. Он форматирует пробелы и отступы для создания кода в соответствии с общим стилем , если не указано иное. Его можно вызвать как отдельную программу или из проекта Rust через Cargo.

Пример вывода Clippy в программе hello world на Rust

Клиппи

Clippy — это встроенный в Rust инструмент проверки , позволяющий улучшить корректность, производительность и читаемость кода Rust. По состоянию на 2024 год , он имеет более 700 правил.

Система версий

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

Каждые два-три года выпускается новое «издание». Выпускаются версии, позволяющие вносить ограниченные критические изменения , например продвигать awaitк ключевому слову для поддержки функций async/await . Крейты, предназначенные для разных выпусков, могут взаимодействовать друг с другом, поэтому крейт может обновиться до новой редакции, даже если его вызывающие программы или его зависимости по-прежнему ориентированы на более старые выпуски. Переход на новую редакцию можно облегчить с помощью автоматизированных инструментов.

Поддержка IDE

Самый популярный языковой сервер для Rust — Rust Analyzer , который официально заменил исходный языковой сервер RLS в июле 2022 года. Rust Analyzer предоставляет IDE и текстовым редакторам информацию о проекте Rust; базовые функции, включая автодополнение и отображение ошибок компиляции при редактировании.

Производительность

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

Rust предоставляет два «режима»: безопасный и небезопасный. Безопасный режим — это «обычный» режим, в котором написана большая часть Rust. В небезопасном режиме разработчик несет ответственность за безопасность памяти кода, что полезно в случаях, когда компилятор слишком ограничителен.

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

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

Принятие

См. Также: Категория: Программное обеспечение Rust (язык программирования).

Ранняя домашняя страница браузерного движка Mozilla Servo

Rust использовался в программном обеспечении в разных областях. Первоначально Rust финансировался Mozilla в рамках разработки Servo, экспериментального параллельного браузерного движка, в сотрудничестве с Samsung . Компоненты движка Servo позже были включены в движок браузера Gecko , лежащий в основе Firefox. В январе 2023 года Google ( Alphabet ) объявила о поддержке сторонних библиотек Rust в Chromium и, следовательно, в базе кода ChromeOS .

Rust используется в нескольких проектах серверного программного обеспечения крупных веб-сервисов . OpenDNS , служба разрешения DNS , принадлежащая Cisco , использует Rust внутри себя. Amazon Web Services начала разработку проектов на Rust еще в 2017 году. включая Firecracker , решение для виртуализации; Bottlerocket, Linux решение для распространения и контейнеризации ; и Tokio — асинхронный сетевой стек. Microsoft Azure IoT Edge, платформа, используемая для запуска сервисов Azure на устройствах Интернета вещей , имеет компоненты, реализованные на Rust. Microsoft также использует Rust для запуска контейнерных модулей с помощью WebAssembly и Kubernetes . Cloudflare , компания, предоставляющая сетевые услуги доставки контента, использует Rust для своего механизма сопоставления шаблонов брандмауэра и веб-сервера Pingora .

добавлена ​​поддержка Rust. В операционных системах в Linux и Андроид . Microsoft переписывает части Windows на Rust. Проект r9 направлен на повторную реализацию Plan 9 от Bell Labs в Rust. Rust использовался при разработке новых операционных систем, таких как Redox , «Unix-подобная» операционная система и микроядро . Тесей, экспериментальная операционная система с модульным управлением состояниями, и большая часть фуксии . Rust также используется для инструментов командной строки и компонентов операционной системы, включая stratisd , файловой системы. менеджер и COSMIC, среда рабочего стола от System76 .

Ruffle, веб-эмулятор для Adobe Flash. SWF -файлов

В веб-разработке менеджер пакетов npm начал использовать Rust в 2019 году. Deno , безопасная среда выполнения для JavaScript и TypeScript , создана с использованием V8 , Rust и Tokio. Другие заметные разработки в этой области включают Ruffle с открытым исходным кодом , эмулятор SWF , и Polkadot , платформа блокчейна и криптовалют с открытым исходным кодом .

Discord , социальная платформа для обмена мгновенными сообщениями, использует Rust для некоторых частей своей серверной части, а также для кодирования видео на стороне клиента . В 2021 году Dropbox объявила об использовании Rust для службы захвата экрана, видео и изображений. Facebook ( Meta ) использовал Rust для Mononoke, сервера системы контроля версий Mercurial .

В опросе разработчиков Stack Overflow 2023 года 13% респондентов недавно провели обширную разработку на Rust. Опрос также называл Rust «самым любимым языком программирования» каждый год с 2016 по 2023 год (включительно), исходя из количества разработчиков, заинтересованных в продолжении работы на том же языке. В 2023 году Rust занял 6-е место среди «самых востребованных технологий», при этом 31% разработчиков, которые в настоящее время не работают в Rust, выразили заинтересованность в этом.

Сообщество

Некоторые пользователи Rust называют себя Rustaceans (по аналогии со словом ракообразное ) и сделали оранжевого краба Ферриса своим неофициальным талисманом.

Фонд ржавчины

Фонд ржавчины

Формирование	8 февраля 2021 г ( 08.02.2021 )
Основатели	Веб-сервисы Amazon Google Хуавей Майкрософт Фонд Мозиллы
Тип	Некоммерческая организация
Расположение	Соединенные Штаты
Председатель	Шейн Миллер
Исполнительный директор	Ребекка Рамбул
Веб-сайт	фундамент .отдых .org

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

Он был создан 8 февраля 2021 года пятью корпоративными членами-учредителями (Amazon Web Services, Huawei, Google, Microsoft и Mozilla). Совет фонда возглавляет Шейн Миллер. С конца 2021 года ее исполнительным директором и генеральным директором станет Ребекка Рамбул. До этого временным исполнительным директором была Эшли Уильямс.

Управляющие команды

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

См. также

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

Ссылки

Источники книг

• Гьенгсет, Джон (2021). Ржавчина для рустообразных (1-е изд.). Нет крахмального пресса. ISBN  9781718501850 . OCLC   1277511986 .
• Клабник, Стив; Николс, Кэрол (12 августа 2019 г.). Язык программирования Rust (охватывает Rust 2018) . Нет крахмального пресса. ISBN  978-1-7185-0044-0 .
• Блэнди, Джим; Орендорф, Джейсон; Тиндалл, Леонора Ф.С. (2021). Программирование на Rust: быстрая и безопасная разработка систем (2-е изд.). О'Рейли Медиа. ISBN  978-1-4920-5254-8 . OCLC   1289839504 .
• Макнамара, Тим (2021). Ржавчина в действии . Публикации Мэннинга. ISBN  978-1-6172-9455-6 . OCLC   1153044639 .
• Клабник, Стив; Николс, Кэрол (2023). Язык программирования Rust (2-е изд.). Нет крахмального пресса. ISBN  978-1-7185-0310-6 . OCLC   1363816350 .

Дальнейшее чтение

• Блэнди, Джим; Орендорф, Джейсон; Тиндалл, Леонора Ф.С. (06 июля 2021 г.). Программирование на Rust: быстрая и безопасная разработка систем . О'Рейли Медиа. ISBN  978-1-4920-5259-3 .

Внешние ссылки

• Официальный веб-сайт