stringtranslate.com

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

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

Rust не навязывает парадигму программирования , но на него повлияли идеи функционального программирования , включая неизменяемость , функции высшего порядка , алгебраические типы данных и сопоставление с образцом . Он также поддерживает объектно-ориентированное программирование с помощью структур, перечислений , черт и методов. Он популярен для системного программирования . [13] [14] [15]

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

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

История

Ранние годы (2006–2009)

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

Rust начинался как личный проект в 2006 году сотрудника Mozilla Грейдона Хоара. [16] Хоар заявил, что Rust был назван в честь группы грибов , которые «сверхусовершенствованы для выживания». [16] В период между 2006 и 2009 годами Rust не был представлен другим сотрудникам Mozilla и был написан в свободное время Хоара; [17] Хоар начал говорить о языке около 2009 года после того, как небольшая группа в Mozilla заинтересовалась проектом. [18] Хоар подчеркнул приоритетность хороших идей из старых языков над новыми разработками, ссылаясь на такие языки, как CLU (1974), BETA (1975), Mesa (1977), NIL (1981), Erlang (1987), Newsqueak (1988), Napier (1988), Hermes (1990), Sather (1990), Alef (1992) и Limbo (1996) как на оказавшие влияние, заявив, что «многие старые языки [лучше] новых», и описав язык как «технологию из прошлого, пришедшую, чтобы спасти будущее от самого себя». [17] [18] Ранний разработчик Rust Маниш Горегаокар аналогичным образом описал Rust как основанный на «в основном на многолетних исследованиях». [16]

В ранние годы компилятор Rust был написан примерно на 38 000 строках OCaml . [17] [19] Ранний Rust содержал такие функции, как явное объектно-ориентированное программирование с помощью objключевого слова (позже удаленного) и систему для так называемых typestates , которая позволяла отслеживать переменные типа вместе с изменениями состояния (например, переход от неинициализированного к инициализированному). Функции были чистыми по умолчанию, что означало, что побочные эффекты (например, чтение или запись в файл) не допускались без явной аннотации. [17]

Спонсорство Mozilla (2009–2012)

Mozilla официально спонсировала проект Rust в 2009 году. [16] Брендан Эйх и другие руководители, заинтригованные возможностью использования Rust для безопасного движка веб-браузера , назначили инженеров на проект, включая Патрика Уолтона, Нико Мацакиса, Феликса Клока и Маниша Горегаокара. Конференц-зал, занятый разработчиками проекта, был окрещен «пещерой ботаников», с табличкой, размещенной снаружи двери. [16]

В этот период времени работа перешла от первоначального компилятора OCaml к самостоятельным компиляторам , т. е . написанным на Rust, на основе LLVM . [20] [примечание 4] Система собственности Rust также была введена в действие к 2010 году. [16] Логотип Rust был разработан в 2011 году на основе велосипедной цепной передачи . [22]

Первый публичный релиз Rust 0.1 был выпущен в январе 2012 года. [20] [ требуется лучший источник ] В начале 2010-х годов наблюдалось увеличение участия добровольцев с открытым исходным кодом за пределами Mozilla и за пределами Соединенных Штатов. В Mozilla руководители в конечном итоге наняли более дюжины инженеров для работы над Rust на постоянной основе в течение следующего десятилетия. [16]

Эволюция (2012–2015)

Годы с 2012 по 2015 были отмечены существенными изменениями в системе типов Rust , в частности, удалением системы typestate, консолидацией других языковых функций и удалением сборщика мусора . [17] [16] Управление памятью через систему владения постепенно консолидировалось и расширялось для предотвращения ошибок, связанных с памятью. К 2013 году функция сборщика мусора использовалась редко и была удалена командой в пользу системы владения. [16] Другие изменения за это время включали удаление чистых функций , которые были объявлены явной pureаннотацией, в марте 2013 года. [23] Специализированная поддержка синтаксиса для каналов и различных типов указателей была удалена для упрощения языка. [17]

Расширение и консолидация Rust происходили под влиянием разработчиков, пришедших из C++ (например, низкоуровневая производительность функций), скриптовых языков (например, Cargo и управление пакетами) и функционального программирования (например, разработка систем типов). [17]

Грейдон Хоар ушел из Rust в 2013 году. [16] Это позволило ему развиваться органично в рамках более федеративной структуры управления с «основной командой» из 6 человек изначально, 30-40 разработчиков в различных других командах в общей сложности и процессом запроса комментариев (RFC) для новых языковых функций, добавленным в марте 2014 года. [17] Основная команда выросла до 9 человек к 2016 году с более чем 1600 предложенными RFC. [17]

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

Спустя шесть лет после того, как Mozilla спонсировала его разработку, 15 мая 2015 года был опубликован первый стабильный релиз Rust 1.0. [16] Через год после выпуска компилятор Rust собрал более 1400 участников, а на сайте управления пакетами Rust Crates.io было опубликовано более 5000 сторонних библиотек. [17]

Выпуск сервоприводов и их промышленное внедрение (2015–2020 гг.)

Разработка браузерного движка Servo продолжалась параллельно с Rust. Команды, стоящие за двумя проектами, работали в тесном сотрудничестве; новые функции в Rust тестировались командой Servo, а новые функции в Servo использовались для обратной связи с командой Rust. [17] Первая версия Servo была выпущена в 2016 году . [16] Веб- браузер Firefox поставлялся с кодом Rust по состоянию на 2016 год (версия 45); [17] [25] , но компоненты Servo не появлялись в Firefox до сентября 2017 года (версия 57) как часть проектов Gecko и Quantum . [26]

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

Самым ранним принятием за пределами Mozilla стали отдельные проекты в Samsung , Facebook (теперь Meta Platforms ), Dropbox и других, включая Tilde, Inc. (компания, стоящая за ember.js ). [17] [16] В 2020 году последовала за ней Amazon Web Services . [16] Инженеры назвали производительность, отсутствие сборщика мусора, безопасность и приятность работы на языке причинами принятия, признав при этом, что это была рискованная ставка, поскольку Rust был новой технологией. Разработчики Amazon сослались на тот факт, что Rust потребляет вдвое меньше электроэнергии , чем аналогичный код, написанный на Java , уступая только C , [16] как было обнаружено в исследовании в Университете Минью , Университете NOVA в Лиссабоне и Университете Коимбры . [27] [примечание 5]

Увольнения в Mozilla и Rust Foundation (2020–настоящее время)

В августе 2020 года Mozilla уволила 250 из 1000 своих сотрудников по всему миру в рамках корпоративной реструктуризации, вызванной пандемией COVID-19 . [28] [29] Команда Servo была расформирована. Это событие вызвало опасения по поводу будущего Rust из-за совпадения двух проектов. [30] На следующей неделе основная команда Rust признала серьезное влияние увольнений и объявила о планах создания фонда Rust. Первой целью фонда будет принятие на себя всех товарных знаков и доменных имен , а также финансовая ответственность за их расходы. [31]

8 февраля 2021 года пять компаний-основателей: Amazon Web Services , Google , Huawei , Microsoft и Mozilla объявили о создании Rust Foundation . [32] [33] Фонд, возглавляемый Шейном Миллером в течение первых двух лет, предлагал гранты в размере 20 000 долларов и другую поддержку программистам, работающим над основными функциями Rust. [16] В сообщении в блоге , опубликованном 6 апреля 2021 года, Google объявила о поддержке Rust в рамках Android Open Source Project в качестве альтернативы C/C++. [34]

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

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

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

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

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

Ниже представлена ​​программа "Hello, World!" на Rust. fnКлючевое слово обозначает функцию , а println! макрос (см. § Макросы) выводит сообщение на стандартный вывод . [41] Операторы в Rust разделяются точкой с запятой .

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

Переменные

Переменные в Rust определяются с помощью letключевого слова. [42] В приведенном ниже примере значение присваивается переменной с именем foo.

fn  main () { let foo = 10 ; println! ( "Значение foo равно {foo}" ); }

Переменные по умолчанию неизменяемы , а добавление mutключевого слова позволяет изменять переменную. [43] В следующем примере используется //, что обозначает начало комментария . [ 44]

fn  main () { let mut foo = 10 ; // Этот код не скомпилируется без добавления "mut". println! ( "Значение foo равно {foo}" ); foo = 20 ; println! ( "Значение foo равно {foo}" ); }

Несколько letвыражений могут определять несколько переменных с одинаковым именем, что известно как затенение переменных . Затенение переменных позволяет преобразовывать переменные без необходимости называть их по-разному. [45] В примере ниже объявляется новая переменная с тем же именем, которое в два раза больше исходного значения:

fn  main () { let foo = 10 ; println! ( "Значение foo равно {foo}" ); let foo = foo * 2 ; println! ( "Значение foo равно {foo}" ); }

Переменное затенение также возможно для значений разных типов, начиная от строки и заканчивая ее длиной:

fn  main () { пусть пробелы = " " ; пусть пробелы = пробелы . len (); }

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

В Rust блоки кода разделяются фигурными скобками . [46]

ifблоки

Условное if выражение выполняет код на основе того, является ли заданное значение true. elseможет использоваться, когда значение вычисляется как false, и может использоваться для объединения нескольких выражений. [47]else if

fn  main () { let x = 10 ; if x > 5 { println! ( "значение больше пяти" ); }             if x % 7 == 0 { println! ( "значение делится на 7" ); } else if x % 5 == 0 { println! ( "значение делится на 5" ); } else { println! ( "значение не делится на 7 или 5" ); } }

whileпетли

whileможет использоваться для повторения блока кода, пока выполняется условие. [48]

fn  main () { // Перебираем все целые числа от 4 до 10 let mut value = 4 ; while value <= 10 { println! ( "value = {value}" ); value += 1 } }

forциклы и итераторы

Циклы For в Rust обходят элементы коллекции. [49] Выражения «For» работают с любым типом итератора .

fn  main (){ // Использование `for` с синтаксисом диапазона для той же функциональности, что и выше for value in 4 ..= 10 { println! ( "value = {value}" ); } }

В приведенном выше коде 4..=10есть значение типа Range, реализующее Iteratorчерту. Код в фигурных скобках применяется к каждому элементу, возвращаемому итератором.

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

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

loopи breakзаявления

В более общем смысле, loopключевое слово позволяет повторять часть кода до тех пор, пока breakне произойдет a. breakможет опционально выйти из цикла со значением. Метки, обозначенные как , могут использоваться для прерывания внешнего цикла, когда циклы вложены. [50]'label_name

fn  main () { let value = 456 ; let mut x = 1 ; let y = loop { x *= 10 ; if x > value { break x / 10 ; } }; println! ( "наибольшая степень десяти, которая меньше или равна значению: {y}" );                               пусть mut up = 1 ; ' внешний : цикл { пусть mut down = 120 ; цикл { если вверх > 100 { break 'внешний ; }                      если вниз < 4 { перерыв ; }       вниз /= 2 ; вверх += 1 ; println! ( "вверх: {вверх}, вниз: {вниз}" ); } вверх *= 2 ; } }

Выражения

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

fn  факториал ( i : u64 )  -> u64  { если i == 0 { 1 } иначе { i * факториал ( i - 1 ) } }

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

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

Сопоставление с образцом

Выражения matchи могут использоваться для сопоставления с образцом . Например, можно использовать для удвоения необязательного целочисленного значения, если оно присутствует, и возврата нуля в противном случае: [53]if letmatch

fn  double ( x : Option < u64 > )  -> u64  { match x { Some ( x ) => x * 2 , None => 0 , } }

Эквивалентно это можно записать с помощью и :if letelse

fn  double ( x : Option < u64 > )  -> u64  { if let Some ( x ) = x { x * 2 } else { 0 } }

Типы

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

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

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

Целочисленные типы в Rust именуются на основе знака и количества бит, которые занимает тип. Например, i32— это знаковое целое число, которое занимает 32 бита памяти, тогда как u8— беззнаковое и занимает только 8 бит памяти. isizeи usizeзанимают память в зависимости от архитектуры компьютера, на котором выполняется код, например, на компьютерах с 32-битной архитектурой оба типа будут занимать 32 бита пространства.

По умолчанию целочисленные литералы имеют основание 10, но поддерживаются различные основания с префиксами, например, 0b11для двоичных чисел , 0o567для восьмеричных чисел и 0xDBдля шестнадцатеричных чисел . По умолчанию целочисленные литералы по умолчанию имеют i32тип . Такие суффиксы, как , 4u32могут использоваться для явного задания типа литерала. [56] Байтовые литералы, как , b'X'доступны для представления значения ASCII (в u8) определенного символа. [57]

Булев тип называется , boolкоторый может принимать значение либо , trueлибо false. A charзанимает 32 бита и представляет скалярное значение Unicode: кодовую точку Unicode, которая не является суррогатом . [58] Числа с плавающей точкой IEEE 754 поддерживаются с помощью f32для чисел с плавающей точкой одинарной точности и f64для чисел с плавающей точкой двойной точности . [59]

Типы, определяемые пользователем

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

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

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

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

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

Указатели

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

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

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

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

пусть x = 1000 ; println! ( "1000 как u16 это: {}" , x как u16 );

Право собственности

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

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

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

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

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

Время жизни объекта относится к периоду времени, в течение которого ссылка действительна; то есть, времени между созданием и уничтожением объекта. [90] Эти времена жизни неявно связаны со всеми типами ссылок Rust. Хотя они часто подразумеваются, их также можно указать явно с помощью именованных параметров времени жизни (часто обозначаемых 'a, 'bи т. д.). [91]

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

fn  main () { let x = 5 ; // ------------------+- Время жизни 'a // | let r = & x ; // -+-- Время жизни 'b | // | | println! ( "r: {}" , r ); // | | // | | // -+ | } // ------------------+

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

fn  main () { let r ; // ------------------+- Время жизни 'a // | { // | let x = 5 ; // -+-- Время жизни 'b | r = & x ; // | | // Здесь ОШИБКА: x не живет достаточно долго } // -| | // | println! ( "r: {}" , r ); // | } // ------------------+

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

Время жизни может быть указано с помощью явных параметров времени жизни в аргументах функции. Например, следующий код указывает, что ссылка, возвращаемая функцией, имеет то же время жизни, что и original(и не обязательно то же время жизни, что и prefix): [96]

fn  remove_prefix <' a > ( mut original : & ' a str , prefix : & str ) -> & ' a str { if original . starts_with ( prefix ) { original = original [ prefix . len () .. ]; } original }

Когда определяемые пользователем типы содержат ссылки на данные, им также необходимо использовать параметры времени жизни. В примере ниже анализируются некоторые параметры конфигурации из строки и создается структура, содержащая параметры. Функция parse_configтакже демонстрирует исключение времени жизни, что снижает необходимость явного определения параметров времени жизни. [97]

использовать std :: collections :: HashMap ; // Эта структура имеет один параметр времени жизни, 'src. Имя используется только в определении структуры. #[derive(Debug)] struct  Config <' src > { hostname : & ' src str , username : & ' src str , }     // Параметр '_lifetime в этом случае относится к анонимному времени жизни, прикрепленному к типу // аргумента `config`. fn  parse_config ( config : & str )  -> Config <' _ > { let key_values ​​: HashMap < _ , _ > = config .lines ( ) .filter ( | line | ! line .starts_with ( '#' )) .filter_map ( | line | line .split_once ( ' =' )) .map ( | ( key , value ) | ( key.trim ( ), value.trim ( ) )) .collect ( ); Config { hostname : key_values [ " hostname " ], username : key_values [ " username " ] , } }                     fn  main () { let config = parse_config ( r#"hostname = foobar username=barfoo"# , ); println! ( "Проанализированная конфигурация: {:#?}" , config ); }

В компиляторе владение и время жизни работают вместе, чтобы предотвратить проблемы безопасности памяти, такие как зависшие указатели. [98]

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

Полиморфизм

Дженерики

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

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

использовать 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 ); println! ( "Сумма: {}" , result1 ); // Сумма: 30          let result2 = sum ( 10.23 , 20.45 ); println! ( "Сумма равна: {}" , result2 ); // Сумма равна: 30.68 }

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

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

Черты

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

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

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

Объекты-черты

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

использовать std :: fmt :: Display ; пусть v : Vec < Box < dyn Display >> = vec! [ Box :: new ( 3 ), Box :: new ( 5.0 ), Box :: new ( "hi" ), ];       для x в v { println! ( "{x}" ); }

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

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

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

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

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

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

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

Макросы

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

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

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

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

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

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

Макрос rsx!в фреймворке фронтенда Dioxus является примером макроса, похожего на функцию. [123] [124] Макрос [125] предоставляет широко используемую библиотеку для генерации кода для чтения и записи данных во многих форматах, таких как JSON .serde_derive Макросы атрибутов обычно используются для языковых привязок, таких как библиотека для привязок Rust к R. [126]extendr

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

использовать serde :: { Сериализация , Десериализация };  #[derive(Сериализация, Десериализация, Отладка)] структура  Point { x : i32 , y : i32 , }   fn  main () { пусть точка = Точка { x : 1 , y : 2 };          пусть сериализовано = serde_json :: to_string ( & point ). unwrap (); println! ( "сериализовано = {}" , сериализовано );      пусть десериализовано : Point = serde_json :: from_str ( & сериализовано ). unwrap (); println! ( "десериализовано = {:?}" , десериализовано ); }

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

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

macro_rules! calculate { // Шаблон для одного `eval` ( eval $e : expr ) => {{ { let val : usize = $e ; // Принудительно сделать типы целыми числами println! ( "{} = {}" , stringify! { $e }, val ); } }};                   // Рекурсивно разложить несколько `eval`ов ( eval $e : expr , $( eval $es : expr ), + ) => {{ calculate ! { eval $e } calculate ! { $( eval $es ), + } }}; }                 fn  main () { calculate ! { // Смотри, ма! Variadic `calculate!`! eval 1 + 2 , eval 3 + 4 , eval ( 2 * 3 ) + 1 } }
Rust может взаимодействовать с вариативной системой C через c_variadicпереключатель функций. Как и в случае с другими интерфейсами C, система считается unsafeRust. [128]

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

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

Экосистема

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

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

Компилятор

Компилятор Rust, rustc, транслирует код Rust в низкоуровневый LLVM IR . Затем LLVM вызывается как подкомпонент для применения оптимизаций и трансляции полученного IR в объектный код . Затем компоновщик используется для объединения объектов в один исполняемый образ или двоичный файл. [132]

Помимо LLVM, компилятор также поддерживает использование альтернативных бэкэндов, таких как GCC и Cranelift, для генерации кода. [133] Цель этих альтернативных бэкэндов — увеличить покрытие платформы Rust или улучшить время компиляции. [134] [135]

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

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

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

Грузовой

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

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

Rustfmt

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

Пример вывода Clippy в программе Hello World на Rust

Клиппи

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

Система управления версиями

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

Каждые два или три года выпускается новая «редакция». Редакции выпускаются для того, чтобы разрешить внесение ограниченных критических изменений , таких как повышение awaitдо ключевого слова для поддержки функций async/await . Ящики, ориентированные на разные редакции, могут взаимодействовать друг с другом, поэтому ячейка может обновиться до новой редакции, даже если ее вызывающие или ее зависимости все еще нацелены на старые редакции. Миграция на новую редакцию может быть выполнена с помощью автоматизированных инструментов. [143]

Поддержка IDE

rust-analyzer — это набор утилит, которые предоставляют интегрированным средам разработки (IDE) и текстовым редакторам информацию о проекте Rust через протокол Language Server Protocol . Это позволяет использовать такие функции, как автодополнение и отображение ошибок компиляции во время редактирования. [144]

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

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

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

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

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

Принятие

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

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

Rust используется в нескольких внутренних программных проектах крупных веб-сервисов . OpenDNS , служба разрешения DNS , принадлежащая Cisco , использует Rust внутри компании. [161] [162] Amazon Web Services использует Rust в «чувствительных к производительности компонентах» своих нескольких сервисов. В 2019 году AWS открыл исходный код Firecracker , решения для виртуализации, в основном написанного на Rust. [163] Microsoft Azure IoT Edge, платформа, используемая для запуска сервисов Azure на устройствах IoT , имеет компоненты, реализованные на Rust. [164] Microsoft также использует Rust для запуска контейнерных модулей с WebAssembly и Kubernetes . [165] Cloudflare , компания, предоставляющая сетевые сервисы доставки контента , использовала Rust для создания нового веб-прокси под названием Pingora для повышения производительности и эффективности. [166] Менеджер пакетов npm начал использовать Rust для своей службы аутентификации в производственной среде в 2019 году. [167] [168] [169]

В операционных системах разработчики Android использовали Rust в 2021 году для переписывания существующих компонентов. [170] [171] Проект Rust для Linux , запущенный в 2020 году, добавил начальную поддержку Rust в Linux в конце 2022 года, а первые драйверы Linux, написанные на Rust, были выпущены в конце 2023 года. [172] [173] Microsoft переписывает части Windows на Rust. [174] Проект r9 направлен на повторную реализацию Plan 9 от Bell Labs на Rust. [175] Rust использовался при разработке новых операционных систем, таких как Redox , «Unix-подобная» операционная система и микроядро , [176] Theseus, экспериментальная операционная система с модульным управлением состоянием, [177] [178] и большая часть Fuchsia . [179] Rust также используется для инструментов командной строки и компонентов операционной системы, включая stratisd , менеджер файловой системы [180] [181] и COSMIC, среду рабочего стола от System76 . [182]

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

Discord , компания, занимающаяся программным обеспечением для обмена мгновенными сообщениями , переписала части своей системы на Rust для повышения производительности в 2020 году. В том же году Dropbox объявила, что ее синхронизация файлов была переписана на Rust. Facebook ( Meta ) также использовала Rust для перепроектирования своей системы, которая управляет исходным кодом для внутренних проектов. [16]

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

В академических исследованиях

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

В журнальной статье, опубликованной в Proceedings of the International Astronomical Union , астрофизики Бланко-Куаресма и Больмонт повторно реализовали программы, отвечающие за моделирование многопланетных систем на Rust, и обнаружили, что он является конкурентоспособным языком программирования благодаря своей «скорости и точности». [14] Аналогичным образом, статья, опубликованная в Nature, поделилась несколькими историями о биоинформатиках, использующих Rust из-за его производительности и безопасности. [137] Однако обе статьи ссылались на уникальные концепции Rust, включая его систему собственности, которую трудно изучить, как на один из главных недостатков принятия Rust.

Сообщество

Ярко-оранжевый значок краба
Некоторые пользователи Rust называют себя Rustaceans (похоже на слово crustacean ) и выбрали оранжевого краба Ферриса в качестве своего неофициального талисмана. [190] [191]

Rust был отмечен как инклюзивное сообщество, и особенно приветствовал людей из квир-сообщества , отчасти из-за его кодекса поведения , который обрисовал набор ожиданий для членов сообщества Rust, которым нужно следовать. Одна статья MIT Technology Review описала сообщество Rust как «необычно дружелюбное» к новичкам. [16] [137]

Rust Foundation

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

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

Команды управления

Проект Rust состоит из команд , которые отвечают за различные подобласти разработки. Команда компилятора разрабатывает, управляет и оптимизирует внутренние компоненты компилятора; а команда языка проектирует новые языковые функции и помогает их внедрять. На веб-сайте проекта Rust перечислены 6 команд высшего уровня по состоянию на июль 2024 года . [196] Представители команд формируют Совет лидеров, который курирует проект Rust в целом. [197]

Смотрите также

Примечания

  1. ^ Включая инструменты сборки, инструменты хоста и поддержку стандартной библиотеки для x86-64 , ARM , MIPS , RISC-V , WebAssembly , i686 , AArch64 , PowerPC и s390x . [2]
  2. ^ Включая Windows , Linux , macOS , FreeBSD , NetBSD и Illumos . Инструменты сборки хоста на Android , iOS , Haiku , Redox и Fuchsia официально не поставляются; эти операционные системы поддерживаются в качестве целевых. [2]
  3. ^ Зависимости третьих лиц, например, LLVM или MSVC , подпадают под действие их собственных лицензий. [3] [4]
  4. ^ Список версий компилятора Rust (называемый цепочкой самозагрузки) имеет историю, восходящую к 2012 году. [21]
  5. ^ Энергопотребление по сравнению с C было на 3% больше для Rust и на 34% больше для C++; время было на 4% больше и 56% больше соответственно.
  6. ^ В системах Unix это часто строки UTF-8 без внутреннего байта 0. В Windows это строки UTF-16 без внутреннего байта 0. В отличие от них, strи Stringвсегда являются допустимыми UTF-8 и могут содержать внутренние нули.
  7. ^ То есть, среди респондентов, которые «занимались обширной разработкой [с Rust] в течение последнего года» (13,05%), у Rust был самый большой процент тех, кто также выразил заинтересованность «работать над [Rust] в течение следующего года» (84,66%). [186]

Ссылки

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

Другие

  1. ^ "Анонс Rust 1.82.0". 2024-10-17 . Получено 2024-10-17 .
  2. ^ ab "Поддержка платформы". Книга Rustc . Получено 2022-06-27 .
  3. ^ "Язык программирования Rust". Язык программирования Rust. 2022-10-19.
  4. ^ "Типы уникальности". Rust Blog . Получено 2016-10-08 . Те из вас, кто знаком со стилем Elm, могут заметить, что обновленные сообщения --explain во многом вдохновлены подходом Elm.
  5. ^ ab "Влияния - The Rust Reference". The Rust Reference . Архивировано из оригинала 2023-11-26 . Получено 2023-12-31 .
  6. ^ "Типы уникальности". Документация Idris 1.3.3 . Получено 14.07.2022 . Они вдохновлены ... типами владения и заимствованными указателями в языке программирования Rust.
  7. ^ "Microsoft открывает на GitHub язык программирования Project Verona, вдохновленный Rust". ZDNet . Архивировано из оригинала 2020-01-17 . Получено 2020-01-17 .
  8. ^ Джалоян, Жорж-Аксель (19 октября 2017 г.). «Безопасные указатели в SPARK 2014». arXiv : 1710.07047 [cs.PL].
  9. ^ Лэттнер, Крис. "Домашняя страница Криса Лэттнера". Nondot.org . Архивировано из оригинала 2018-12-25 . Получено 2019-05-14 .
  10. ^ "V documentation (Introduction)". GitHub . Получено 2023-11-04 .
  11. ^ Йегулалп, Сердар (29.08.2016). «Новый претендент присоединяется к Rust, чтобы свергнуть язык C». InfoWorld . Получено 19.10.2022 .
  12. ^ Эшварла, Прабху (2020-12-24). Практическое системное программирование для разработчиков Rust: создание быстрого и безопасного программного обеспечения для систем Linux/Unix с помощью практических примеров. Packt Publishing Ltd. ISBN 978-1-80056-201-1.
  13. ^ ab Blanco-Cuaresma, Sergi; Bolmont, Emeline (2017-05-30). «Что может язык программирования Rust сделать для астрофизики?». Труды Международного астрономического союза . 12 (S325): 341–344. arXiv : 1702.02951 . Bibcode : 2017IAUS..325..341B. doi : 10.1017/S1743921316013168. ISSN  1743-9213. S2CID  7857871.
  14. ^ Бланди, Орендорф и Тиндалл, 2021.
  15. ^ abcdefghijklmnopqr Томпсон, Клайв (14.02.2023). «Как Rust превратился из стороннего проекта в самый любимый в мире язык программирования». MIT Technology Review . Получено 23.02.2023 .
  16. ^ abcdefghijklmno Клабник, Стив (2016-06-02). "История Rust". Applicative 2016 on - Applicative 2016 . Нью-Йорк, Нью-Йорк, США: Ассоциация вычислительной техники. стр. 80. doi :10.1145/2959689.2960081. ISBN 978-1-4503-4464-7.
  17. ^ abc Hoare, Graydon (июль 2010 г.). Project Servo: Технологии прошлого пришли, чтобы спасти будущее от самого себя (PDF) . Mozilla Annual Summit. Архивировано из оригинала (PDF) 2021-12-26 . Получено 2024-10-29 .
  18. ^ Хоар, Грейдон (ноябрь 2016 г.). «Предыстория Rust (Архив исходного кода оригинального компилятора Rust OCaml)». GitHub . Получено 29 октября 2024 г.
  19. ^ ab "0.1 first supported public release Milestone · rust-lang/rust". GitHub . Получено 29.10.2024 .
  20. ^ Нельсон, Джинн (05.08.2022). RustConf 2022 — Bootstrapping: The once and future compiler. Портленд, Орегон: Rust Team . Получено 29.10.2024 — через YouTube.
  21. ^ "Логотип Rust". bugzilla.mozilla.org . Получено 2024-02-02 .
  22. ^ "Purity by pcwalton · Pull Request #5412 · rust-lang/rust". GitHub . Получено 29.10.2024 .
  23. ^ Бинсток, Эндрю (2014-01-07). «Взлет и падение языков в 2013 году». Журнал доктора Добба . Архивировано из оригинала 2016-08-07 . Получено 2022-11-20 .
  24. ^ "Firefox 45.0, см. все новые функции, обновления и исправления". Mozilla . Получено 2024-10-31 .
  25. ^ Лардинуа, Фредерик (29.09.2017). «Пора дать Firefox еще один шанс». TechCrunch . Получено 15.08.2023 .
  26. ^ Перейра, Руи; Коуто, Марко; Рибейро, Франциско; Руа, Руи; Кунья, Хакоме; Фернандес, Жоау Паулу; Сарайва, Жуан (23 октября 2017 г.). «Энергоэффективность в разных языках программирования: как связаны энергия, время и память?». Материалы 10-й Международной конференции ACM SIGPLAN по языковой инженерии программного обеспечения . SLE 2017. Нью-Йорк, штат Нью-Йорк, США: Ассоциация вычислительной техники. стр. 256–267. дои : 10.1145/3136014.3136031. hdl : 1822/65359. ISBN 978-1-4503-5525-4.
  27. ^ Cimpanu, Catalin (2020-08-11). «Mozilla увольняет 250 сотрудников, переориентируясь на коммерческие продукты». ZDNet . Архивировано из оригинала 2022-03-18 . Получено 2020-12-02 .
  28. ^ Купер, Дэниел (2020-08-11). «Mozilla увольняет 250 сотрудников из-за пандемии». Engadget . Архивировано из оригинала 2020-12-13 . Получено 2020-12-02 .
  29. ^ Танг, Лиам. «Язык программирования Rust: сокращение рабочих мест в Mozilla сильно ударило по нам, но вот как мы выживем». ZDNet. Архивировано из оригинала 21.04.2022 . Получено 21.04.2022 .
  30. ^ "Закладка фундамента для будущего Rust". Rust Blog . 2020-08-18. Архивировано из оригинала 2020-12-02 . Получено 2020-12-02 .
  31. ^ "Hello World!". Rust Foundation . 2020-02-08. Архивировано из оригинала 2022-04-19 . Получено 2022-06-04 .
  32. ^ "Mozilla приветствует Rust Foundation". Блог Mozilla . 2021-02-09. Архивировано из оригинала 2021-02-08 . Получено 2021-02-09 .
  33. ^ Амадео, Рон (07.04.2021). «Google теперь пишет низкоуровневый код Android на Rust». Ars Technica . Архивировано из оригинала 08.04.2021 . Получено 08.04.2021 .
  34. ^ Андерсон, Тим (2021-11-23). ​​"Вся команда модераторов Rust уходит в отставку". The Register . Получено 2022-08-04 .
  35. ^ "Обновление управления". Inside Rust Blog . Получено 2022-10-27 .
  36. ^ Клэберн, Томас (2023-04-17). «Rust Foundation приносит извинения за путаницу в политике в отношении товарных знаков». The Register . Получено 2023-05-07 .
  37. ^ Proven, Liam (2019-11-27). "Rebecca Rumbul named new CEO of The Rust Foundation". The Register . Получено 2022-07-14 . Оба языка являются языками с фигурными скобками и синтаксисом, похожим на C, что делает их неустрашимыми для программистов на C.
  38. ^ abc Vigliarolo, Brandon (2021-02-10). «Язык программирования Rust теперь имеет свою собственную независимую основу». TechRepublic . Архивировано из оригинала 2023-03-20 . Получено 14-07-2022 .
  39. ^ Клабник и Николс 2019, стр. 263.
  40. ^ Клабник и Николс 2019, стр. 5–6.
  41. ^ Клабник и Николс 2023, стр. 32.
  42. ^ Клабник и Николс 2023, стр. 32–33.
  43. ^ Клабник и Николс 2023, стр. 49–50.
  44. ^ Клабник и Николс 2023, стр. 34–36.
  45. ^ Клабник и Николс 2023, стр. 6, 44, 47.
  46. ^ Клабник и Николс 2023, стр. 50–52.
  47. ^ Клабник и Николс 2023, стр. 56.
  48. ^ Клабник и Николс 2023, стр. 57–58.
  49. ^ Клабник и Николс 2023, стр. 54–56.
  50. ^ Клабник и Николс 2019, стр. 50–53.
  51. ^ Тайсон, Мэтью (2022-03-03). "Программирование на Rust для разработчиков Java". InfoWorld . Получено 2022-07-14 .
  52. ^ Клабник и Николс 2019, стр. 104–109.
  53. ^ Клабник и Николс 2019, стр. 24.
  54. ^ Клабник и Николс 2019, стр. 36–38.
  55. ^ Клабник и Николс 2023, стр. 36–38.
  56. ^ Клабник и Николс 2023, стр. 502.
  57. ^ "Глоссарий терминов Unicode". Консорциум Unicode . Получено 2024-07-30 .
  58. ^ Клабник и Николс 2019, стр. 38–40.
  59. ^ Клабник и Николс 2019, стр. 83.
  60. ^ Клабник и Николс 2019, стр. 97.
  61. ^ Клабник и Николс 2019, стр. 98–101.
  62. ^ Клабник и Николс 2019, стр. 438–440.
  63. ^ ab Klabnik & Nichols 2019, стр. 93.
  64. ^ "OsStr в std::ffi – Rust". doc.rust-lang.org . Получено 2023-10-02 .
  65. ^ "OsString в std::ffi – Rust". doc.rust-lang.org . Получено 2023-10-02 .
  66. ^ "Путь в std::path – Rust". doc.rust-lang.org . Получено 2023-10-02 .
  67. ^ "PathBuf в std::path – Rust". doc.rust-lang.org . Получено 2023-10-02 .
  68. ^ abc "std::boxed – Rust". doc.rust-lang.org . Получено 2023-06-23 .
  69. ^ "std::boxed – Rust". doc.rust-lang.org . Получено 2023-06-24 .
  70. ^ "Rc в std::rc – Rust". doc.rust-lang.org . Получено 2023-06-24 .
  71. ^ "Arc in std::sync – Rust". doc.rust-lang.org . Получено 2023-06-24 .
  72. ^ "Cell in std::cell – Rust". doc.rust-lang.org . Получено 2023-06-24 .
  73. ^ "Мьютекс в std::sync – Rust". doc.rust-lang.org . Получено 2023-06-24 .
  74. ^ "RwLock в std::sync – Rust". doc.rust-lang.org . Получено 2023-06-24 .
  75. ^ "Condvar в std::sync – Rust". doc.rust-lang.org . Получено 2023-06-24 .
  76. ^ "Длительность в std::time – Rust". doc.rust-lang.org . Получено 2023-06-24 .
  77. ^ "HashMap в std::collections – Rust". doc.rust-lang.org . Получено 2023-06-24 .
  78. ^ "BTreeMap в std::collections – Rust". doc.rust-lang.org . Получено 2023-06-24 .
  79. ^ Макнамара 2021.
  80. ^ Клабник и Николс 2019, стр. 101–104.
  81. ^ "std::option - Rust". doc.rust-lang.org . Получено 12.11.2023 .
  82. ^ ab Klabnik & Nichols 2019, стр. 418–427.
  83. ^ "Литье - Rust на примере". doc.rust-lang.org .
  84. ^ Клабник и Николс 2019, стр. 59–61.
  85. ^ ab Klabnik & Nichols 2019, стр. 63–68.
  86. ^ Клабник и Николс 2019, стр. 74–75.
  87. ^ ab Баласубраманян, Абхирам; Барановский, Марек С.; Бурцев, Антон; Панда, Ауроджит; Ракамарич, Звонимир; Рыжик, Леонид (2017-05-07). "Системное программирование на Rust". Труды 16-го семинара по горячим темам в операционных системах . HotOS '17. Нью-Йорк, штат Нью-Йорк, США: Ассоциация вычислительной техники. стр. 156–161. doi :10.1145/3102980.3103006. ISBN 978-1-4503-5068-6. S2CID  24100599. Архивировано из оригинала 2022-06-11 . Получено 2022-06-01 .
  88. ^ Клабник и Николс 2023, стр. 327–30.
  89. ^ "Lifetimes - Rust By Example". doc.rust-lang.org . Получено 29.10.2024 .
  90. ^ "Явная аннотация - Rust By Example". doc.rust-lang.org . Получено 29.10.2024 .
  91. ^ ab Klabnik & Nichols 2019, стр. 194.
  92. ^ Клабник и Николс 2019, стр. 75, 134.
  93. ^ Шамрелл-Харрингтон, Нелл. «The Rust Borrow Checker – a Deep Dive». InfoQ . Получено 25.06.2022 .
  94. ^ Клабник и Николс 2019, стр. 194–195.
  95. ^ Клабник и Николс 2023, стр. 208–12.
  96. ^ Клабник и Николс 2019, стр. 201–203.
  97. ^ "Ссылки и заимствования - Язык программирования Rust". doc.rust-lang.org . Получено 29.10.2024 .
  98. ^ Клабник и Николс 2019, стр. 171–172.
  99. ^ Клабник и Николс 2019, стр. 171–172, 205.
  100. ^ Клабник и Николс 2019, стр. 181, 182.
  101. ^ Gjengset 2021, стр. 25.
  102. ^ Клабник и Николс 2019, стр. 182–184.
  103. ^ Клабник и Николс 2019, стр. 281–283.
  104. ^ «Использование объектов-характеристик, допускающих значения разных типов – язык программирования Rust». doc.rust-lang.org . Получено 11 июля 2022 г.
  105. ^ Клабник и Николс 2019, стр. 441–442.
  106. ^ Клабник и Николс 2019, стр. 379–380.
  107. ^ Розенблатт, Сет (2013-04-03). "Samsung присоединяется к Mozilla в поисках Rust". CNET . Архивировано из оригинала 2013-04-04 . Получено 2013-04-05 .
  108. ^ Браун, Нил (2013-04-17). "Вкус ржавчины". LWN.net . Архивировано из оригинала 2013-04-26 . Получено 2013-04-25 .
  109. ^ "Расы – Рустономикон". doc.rust-lang.org . Архивировано из оригинала 2017-07-10 . Получено 2017-07-03 .
  110. ^ "Часто задаваемые вопросы о языке Rust". static.rust-lang.org . 2015. Архивировано из оригинала 20-04-2015 . Получено 24-04-2017 .
  111. ^ Макнамара 2021, стр. 139, 376–379, 395.
  112. ^ "RAII – Rust By Example". doc.rust-lang.org . Архивировано из оригинала 2019-04-21 . Получено 2020-11-22 .
  113. ^ "Абстракция без накладных расходов: черты в Rust". Rust Blog . Архивировано из оригинала 2021-09-23 . Получено 2021-10-19 .
  114. ^ "Коробка, стопка и куча". Rust By Example . Получено 2022-06-13 .
  115. ^ Клабник и Николс 2019, стр. 70–75.
  116. ^ Клабник и Николс 2019, стр. 323.
  117. ^ "Макросы по примерам". Справочник Rust . Получено 21.04.2023 .
  118. ^ Клабник и Николс 2019, стр. 446–448.
  119. ^ "Rust std::println! macro source". GitHub . Получено 2024-10-01 .
  120. ^ "Процедурные макросы". Справочник по языку программирования Rust . Архивировано из оригинала 2020-11-07 . Получено 2021-03-23 .
  121. ^ Клабник и Николс 2019, стр. 449–455.
  122. ^ "Источник макроса Dioxus rsx!". GitHub . Получено 2024-10-01 .
  123. ^ "Dioxus rsx! Документация макроса". Dioxus Labs . Получено 2024-10-01 .
  124. ^ "Serde Derive". Документация Serde Derive . Архивировано из оригинала 2021-04-17 . Получено 2021-03-23 .
  125. ^ "extendr_api – Rust". Документация Extendr Api . Архивировано из оригинала 2021-05-25 . Получено 2021-03-23 .
  126. ^ "Variadics". Rust на примере .
  127. ^ "2137-variadic". Книга Rust RFC .
  128. ^ "Безопасное взаимодействие между Rust и C++ с CXX". InfoQ . 2020-12-06. Архивировано из оригинала 2021-01-22 . Получено 2021-01-03 .
  129. ^ "Type layout – The Rust Reference". doc.rust-lang.org . Получено 2022-07-15 .
  130. ^ Бланди, Орендорф и Тиндалл, 2021, стр. 6–8.
  131. ^ "Обзор компилятора". Руководство по разработке компилятора Rust . Участники проекта Rust . Получено 2024-11-07 .
  132. ^ "Генерация кода - Руководство по разработке компилятора Rust". rustc-dev-guide.rust-lang.org . Получено 2024-03-03 .
  133. ^ "rust-lang/rustc_codegen_gcc". GitHub . Язык программирования Rust. 2024-03-02 . Получено 2024-03-03 .
  134. ^ "rust-lang/rustc_codegen_cranelift". GitHub . Язык программирования Rust. 2024-03-02 . Получено 2024-03-03 .
  135. ^ Gjengset 2021, стр. 213-215.
  136. ^ abc Perkel, Jeffrey M. (2020-12-01). «Почему ученые обращаются к Rust». Nature . 588 (7836): 185–186. Bibcode :2020Natur.588..185P. doi :10.1038/d41586-020-03382-2. PMID  33262490. S2CID  227251258. Архивировано из оригинала 2022-05-06 . Получено 2022-05-15 .
  137. ^ Симоне, Серхио Де (2019-04-18). "Rust 1.34 представляет альтернативные реестры для непубличных ящиков". InfoQ . Получено 2022-07-14 .
  138. ^ Клабник и Николс 2019, стр. 511–512.
  139. ^ Clippy, Язык программирования Rust, 2023-11-30 , получено 2023-11-30
  140. ^ "Clippy Lints". Язык программирования Rust . Получено 2023-11-30 .
  141. ^ Клабник и Николс 2019, Приложение G – Как создается ржавчина и «Ночная ржавчина»
  142. ^ Бланди, Орендорф и Тиндалл, 2021, стр. 176–177.
  143. ^ Клабник и Николс 2023, стр. 623.
  144. ^ Макнамара 2021, стр. 11.
  145. ^ Попеску, Натали; Сюй, Цзыян; Апостолакис, Сотирис; Аугуст, Дэвид И.; Леви, Амит (15.10.2021). «Безопаснее на любой скорости: автоматическое контекстно-зависимое улучшение безопасности для Rust». Труды ACM по языкам программирования . 5 (OOPSLA). Раздел 2. doi : 10.1145/3485480 . S2CID  238212612. стр. 5: Мы наблюдаем большую дисперсию в накладных расходах проверенной индексации: 23,6% тестов сообщают о значительном падении производительности из-за проверенной индексации, но 64,5% сообщают о незначительном влиянии или его отсутствии, и, что удивительно, 11,8% сообщают об улучшении производительности ... В конечном счете, хотя непроверенная индексация может улучшить производительность, в большинстве случаев этого не происходит.
  146. ^ Андерсон, Тим. «Может ли Rust спасти планету? Почему и почему нет». The Register . Получено 2022-07-11 .
  147. ^ Йегулалп, Сердар (2021-10-06). "Что такое язык Rust? Безопасная, быстрая и простая разработка программного обеспечения". InfoWorld . Получено 2022-06-25 .
  148. ^ ab Астраускас, Витаутас; Матея, Кристоф; Поли, Федерико; Мюллер, Питер; Саммерс, Александр Дж. (13.11.2020). «Как программисты используют небезопасный Rust?». Труды ACM по языкам программирования . 4 (OOPSLA): 1–27. doi : 10.1145/3428204. hdl : 20.500.11850/465785 . ISSN  2475-1421.
  149. ^ Макнамара 2021, стр. 19, 27.
  150. ^ Couprie, Geoffroy (2015). "Nom, A Byte-ориентированная, потоковая, Zero copy, Parser Combinators Library in Rust". Семинары IEEE по безопасности и конфиденциальности 2015 года . стр. 142–148. doi :10.1109/SPW.2015.31. ISBN 978-1-4799-9933-0. S2CID  16608844.
  151. ^ Макнамара 2021, стр. 20.
  152. ^ "Генерация кода – Справочник по Rust". doc.rust-lang.org . Получено 2022-10-09 .
  153. ^ "How Fast Is Rust?". Часто задаваемые вопросы о языке программирования Rust . Архивировано из оригинала 2020-10-28 . Получено 2019-04-11 .
  154. ^ Фаршин, Алиреза; Барбетт, Том; Рузбех, Амир; Магуайр-младший, Джеральд К.; Костич, Деян (2021). «PacketMill: на пути к сетям со скоростью 100 ГБ/с на ядро». Труды 26-й Международной конференции ACM по архитектурной поддержке языков программирования и операционных систем. стр. 1–17. doi : 10.1145/3445814.3446724. ISBN 9781450383172. S2CID  231949599 . Получено 12.07.2022 . ... Хотя некоторые компиляторы (например, Rust) поддерживают переупорядочивание структур [82], компиляторам C и C++ запрещено переупорядочивать структуры данных (например, struct или class) [74] ...
  155. ^ "Type layout". Справочник Rust . Получено 2022-07-14 .
  156. ^ Лардинойс, Фредерик (2015-04-03). "Mozilla и Samsung объединяются для разработки Servo, браузерного движка следующего поколения от Mozilla для многоядерных процессоров". TechCrunch . Архивировано из оригинала 2016-09-10 . Получено 2017-06-25 .
  157. ^ Кайзер, Грегг (2016-10-31). "Mozilla планирует обновить Firefox в 2017 году". Computerworld . Получено 2023-05-13 .
  158. ^ Клэберн, Томас (2023-01-12). "Google полирует код Chromium слоем Rust". The Register . Получено 2024-07-17 .
  159. ^ "Поддержка использования Rust в проекте Chromium". Блог Google Online Security . Получено 12.11.2023 .
  160. ^ Шенкленд, Стивен (2016-07-12). «Firefox будет переработан, чтобы снова заинтересовать вас». CNET . Получено 2022-07-14 .
  161. ^ Группа исследований безопасности (2013-10-04). "ZeroMQ: помогаем нам блокировать вредоносные домены в реальном времени". Cisco Umbrella . Архивировано из оригинала 2023-05-13 . Получено 2023-05-13 .
  162. ^ Cimpanu, Catalin (2019-10-15). "AWS спонсирует проект Rust". ZDNET . Получено 2024-07-17 .
  163. ^ Николс, Шон (27.06.2018). «Следующий трюк Microsoft? Выбросить вещи из облака в Azure IoT Edge». The Register . Архивировано из оригинала 27.09.2019 . Получено 27.09.2019 .
  164. ^ Tung, Liam. «Microsoft: Почему мы использовали язык программирования Rust вместо Go для WebAssembly в приложении Kubernetes». ZDNet. Архивировано из оригинала 21.04.2022 . Получено 21.04.2022 .
  165. ^ Клэберн, Томас (2022-09-20). «Мы верим в Rust: технический директор Microsoft Azure избегает C и C++». The Register . Получено 07.07.2024 .
  166. ^ Симоне, Серхио Де. «NPM принял Rust для устранения узких мест производительности». InfoQ . Получено 20.11.2023 .
  167. ^ Лю, Шинг (2020), Лю, Шинг (ред.), «Добро пожаловать в мир Rust», Практические проекты Rust: создание игр, физические вычисления и приложения машинного обучения , Беркли, Калифорния: Apress, стр. 1–8, doi : 10.1007/978-1-4842-5599-5_1, ISBN 978-1-4842-5599-5, получено 29.11.2023
  168. ^ Лю, Шинг (2021), Лю, Шинг (ред.), «Rust в мире Интернета», Практические веб-проекты Rust: создание облачных и веб-приложений , Беркли, Калифорния: Apress, стр. 1–7, doi : 10.1007/978-1-4842-6589-5_1, ISBN 978-1-4842-6589-5, получено 29.11.2023
  169. ^ Амадео, Рон (07.04.2021). «Google теперь пишет низкоуровневый код Android на Rust». Ars Technica . Архивировано из оригинала 08.04.2021 . Получено 21.04.2022 .
  170. ^ Darkcrizt (2021-04-02). "Google разрабатывает новый стек Bluetooth для Android, написанный на Rust". Desde Linux . Архивировано из оригинала 2021-08-25 . Получено 2024-08-31 .
  171. ^ Андерсон, Тим (2021-12-07). "Rusty Linux kernel draws closer with new patch". The Register . Получено 2022-07-14 .
  172. ^ "Первый взгляд на Rust в ядре 6.1 [LWN.net]". lwn.net . Получено 2023-11-11 .
  173. ^ Клэберн, Томас (27.04.2023). "Microsoft переписывает основные библиотеки Windows на Rust". The Register . Получено 13.05.2023 .
  174. ^ Доказано, Лиам. «Маленький, но мощный, 9Front's 'Humanbiologics' здесь для действительно любопытных». The Register . Получено 2024-03-07 .
  175. ^ Йегулалп, Сердар. «Rust's Redox OS может показать Linux несколько новых трюков». InfoWorld . Архивировано из оригинала 21.03.2016 . Получено 21.03.2016 .
  176. ^ Андерсон, Тим (14.01.2021). «Еще одна Rust-y OS: Theseus присоединяется к Redox в поисках более безопасных и устойчивых систем». The Register . Получено 14.07.2022 .
  177. ^ Боос, Кевин; Лиянаге, Намита; Иджаз, Рамла; Чжун, Линь (2020). Тесей: эксперимент в области структуры операционной системы и управления состоянием. стр. 1–19. ISBN 978-1-939133-19-9.
  178. ^ Чжан, ХанДун (Алекс) (2023-01-31). "Обзор 2022 года | Внедрение Rust в бизнес". Rust Magazine . Получено 2023-02-07 .
  179. ^ Sei, Mark (2018-10-10). "Fedora 29 new features: Startis now official in Fedora". Marksei, Weekly sysadmin pills . Архивировано из оригинала 2019-04-13 . Получено 2019-05-13 .
  180. ^ Proven, Liam (2022-07-12). "Oracle Linux 9 выпущен с некоторыми интересными дополнениями". The Register . Получено 2022-07-14 .
  181. ^ Proven, Liam (2023-02-02). "System76 дразнит функциями, которые появятся в самодельном десктопе COSMIC на основе Rust". The Register . Получено 2024-07-17 .
  182. ^ Ху, Вивиан (2020-06-12). «Deno готов к производству». InfoQ . Получено 2022-07-14 .
  183. ^ Абрамс, Лоуренс (2021-02-06). «Этот эмулятор Flash Player позволяет вам безопасно играть в ваши старые игры». BleepingComputer . Получено 2021-12-25 .
  184. ^ Хариф, Ольга (17.10.2020). «Убийца блокчейна Ethereum носит скромное имя Polkadot» . Bloomberg LP . Получено 14.07.2021 .
  185. ^ abc "Опрос разработчиков Stack Overflow 2023". Stack Overflow . Получено 25.06.2023 .
  186. ^ Клэбёрн, Томас (2022-06-23). ​​"Линус Торвальдс говорит, что Rust появится в ядре Linux". The Register . Получено 2022-07-15 .
  187. ^ Юнг, Ральф; Журдан, Жак-Анри; Кребберс, Робберт; Дрейер, Дерек (27.12.2017). «RustBelt: закрепление основ языка программирования Rust». Труды ACM по языкам программирования . 2 (POPL): 1–34. doi : 10.1145/3158154. hdl : 21.11116/0000-0003-34C6-3 . ISSN  2475-1421.
  188. ^ Попеску, Натали; Сюй, Цзыян; Апостолакис, Сотирис; Аугуст, Дэвид И.; Леви, Амит (2021-10-20). «Безопаснее на любой скорости: автоматическое контекстно-зависимое улучшение безопасности для Rust». Труды ACM по языкам программирования . 5 (OOPSLA): 1–23. doi : 10.1145/3485480 . ISSN  2475-1421.
  189. ^ Клабник и Николс 2019, стр. 4.
  190. ^ "Getting Started". rust-lang.org . Архивировано из оригинала 2020-11-01 . Получено 2020-10-11 .
  191. ^ Танг, Лиам (2021-02-08). «Язык программирования Rust только что сделал огромный шаг вперед». ZDNet . Получено 2022-07-14 .
  192. ^ Крилл, Пол. «Язык Rust переходит на независимый фундамент». InfoWorld . Архивировано из оригинала 2021-04-10 . Получено 2021-04-10 .
  193. ^ Vaughan-Nichols, Steven J. (2021-04-09). "AWS's Shane Miller to head the newly created Rust Foundation". ZDNet . Архивировано из оригинала 2021-04-10 . Получено 2021-04-10 .
  194. ^ Vaughan-Nichols, Steven J. (17.11.2021). «Rust Foundation назначает Ребекку Рамбул исполнительным директором». ZDNet . Архивировано из оригинала 18.11.2021 . Получено 18.11.2021 .
  195. ^ "Governance". Язык программирования Rust . Архивировано из оригинала 2022-05-10 . Получено 2024-07-18 .
  196. ^ "Представляем Совет лидеров Rust". Блог Rust . Получено 2024-01-12 .

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