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

Ржавчина

Парадигмы	Параллельно функциональный универсальный императив структурированный
Разработчик	Ржавчина Проект
Впервые появился	15 мая 2015 г ( 15 мая 2015 )
Стабильная версия	1.81.0   / 5 сентября 2024 г ( 5 сентября 2024 г. )
Дисциплина набора текста	Аффинный предполагаемый номинальный статический сильный
Язык реализации	ОКамл (2006–2011 гг.) Руст (2012 – настоящее время)
Платформа	Кросс-платформенный
ТЫ	Кросс-платформенный
Лицензия	Массачусетский технологический институт , Апач 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 известен своим быстрым распространением и изучается в исследованиях теории языков программирования .

История

Истоки (2006–2012)

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

Rust зародился как личный проект в 2006 году сотрудника Mozilla Research Грейдона Хоара, названный в честь группы грибов , которые «сверхустроены для выживания». Mozilla начала спонсировать проект в 2009 году и наняла дюжину инженеров для постоянной работы над ним в течение следующих десяти лет.

Примерно в 2010 году работа перешла от первоначального компилятора , написанного на 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!("Hello, World!");
}

Переменные

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

fn main() {
    let foo = 10;
    println!("The value of foo is {foo}");
}

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

fn main() {
    let mut foo = 10; // This code would not compile without adding "mut".
    println!("The value of foo is {foo}");
    foo = 20;
    println!("The value of foo is {foo}");
}

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

fn main() {
    let foo = 10;
    println!("The value of foo is {foo}");
    let foo = foo * 2;
    println!("The value of foo is {foo}");
}

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

fn main() {
    let spaces = "   ";
    let spaces = spaces.len();
}

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

В Rust блоки кода ограничиваются фигурными скобками .

if блоки

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

fn main() {
    let x = 10;
    if x > 5 {
        println!("value is greater than five");
    }

    if x % 7 == 0 {
        println!("value is divisible by 7");
    } else if x % 5 == 0 {
        println!("value is divisible by 5");
    } else {
        println!("value is not divisible by 7 or 5");
    }
}

while петли

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

fn main() {
    // Iterate over all integers from 4 to 10
    let mut value = 4;
    while value <= 10 {
         println!("value = {value}");
         value += 1
    }
}

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

Циклы For в Rust перебирают элементы коллекции. Выражения работают с любым типом итератора .

fn main(){
    // Using `for` with range syntax for the same functionality as above
    for value in 4..=10 {
        println!("value = {value}");
    }
}

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

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

(1..=100).filter(|&x| x % 3 == 0).sum()

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

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

fn main() {
    let value = 456;
    let mut x = 1;
    let y = loop {
        x *= 10;
        if x > value {
            break x / 10;
        }
    };
    println!("largest power of ten that is smaller than value: {y}");

    let mut up = 1;
    'outer: loop {
        let mut down = 120;
        loop {
            if up > 100 {
                break 'outer;
            }

            if down < 4 {
                break;
            }

            down /= 2;
            up += 1;
            println!("up: {up}, down: {down}");
        }
        up *= 2;
    }
}

Выражения

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

fn factorial(i: u64) -> u64 {
    if i == 0 {
        1
    } else {
        i * factorial(i - 1)
    }
}

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

fn factorial(i: u64) -> u64 {
    (2..=i).product()
}

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

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

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

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

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

Типы

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

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

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

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

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

тип Логический называется bool который может принимать значение либо true или false. А char занимает 32 бита пространства и представляет собой скалярное значение Юникода: кодовую точку Юникода , которая не является суррогатом . Числа с плавающей запятой IEEE 754 поддерживаются f32 для поплавков одинарной точности и f64 для чисел с плавающей запятой двойной точности .

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

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

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

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

Краткое описание типов 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>	Указатель на значение, выделенное в куче . в C++ Аналогично std::unique_ptr .	let boxed: Box<u8> = Box::new(5); let val: u8 = *boxed;
Rc<T>	подсчета ссылок Указатель	let five = Rc::new(5); let also_five = five.clone();
Arc<T>	Атомный , потокобезопасный указатель подсчета ссылок	let foo = Arc::new(vec![1.0, 2.0]); let a = foo.clone(); // a can be sent to another thread
Cell<T>	Изменяемая ячейка памяти	let c = Cell::new(5); c.set(10);
Mutex<T>	Блокировка мьютекса для общих данных, содержащихся внутри.	let mutex = Mutex::new(0_u32); let _guard = mutex.lock();
RwLock<T>	Блокировка чтения и записи	let lock = RwLock::new(5); let r1 = lock.read().unwrap();
Condvar	для Условный монитор общих данных	let (lock, cvar) = (Mutex::new(true), Condvar::new()); // As long as the value inside the `Mutex<bool>` is `true`, we wait. let _guard = cvar.wait_while(lock.lock().unwrap(), |pending| { *pending }).unwrap();
Duration	Тип, представляющий промежуток времени	Duration::from_millis(1) // 1ms
HashMap<K, V>	Хэш-таблица	let mut player_stats = HashMap::new(); player_stats.insert("damage", 1); player_stats.entry("health").or_insert(100);
BTreeMap<K, V>	B-дерево	let mut solar_distance = BTreeMap::from([ ("Mercury", 0.4), ("Venus", 0.7), ]); solar_distance.entry("Earth").or_insert(1.0);

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

fn main() {
    let name1: Option<&str> = None;
    // In this case, nothing will be printed out
    if let Some(name) = name1 {
        println!("{name}");
    }

    let name2: Option<&str> = Some("Matthew");
    // In this case, the word "Matthew" will be printed out
    if let Some(name) = name2 {
        println!("{name}");
    }
}

Указатели

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.

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

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

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

let x = 1000;
println!("1000 as a u16 is: {}", x as u16);

Право собственности и время жизни

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

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

fn main() {
    let s = String::from("Hello, World");
    print_string(s); // s consumed by print_string
    // s has been moved, so cannot be used any more
    // another print_string(s); would result in a compile error
}

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

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

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

fn main() {
    let x = 5;                              // ------------------+- Lifetime 'a
                                            //                   |
    let r = &x;                             // -+-- Lifetime 'b  |
                                            //  |                |
    println!("r: {}", r);                   //  |                |
                                            //  |                |
                                            // -+                |
}                                           // ------------------+

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

fn main() {
    let r;                                  // ------------------+- Lifetime 'a
                                            //                   |
    {                                       //                   |
        let x = 5;                          // -+-- Lifetime 'b  |
        r = &x;                             //  |                |
    }                                       // -|                |
                                            //                   |
    println!("r: {}", r);                   //                   |
}                                           // ------------------+

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

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

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

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

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

use std::collections::HashMap;

// This struct has one lifetime parameter, 'src. The name is only used within the struct's definition.
#[derive(Debug)]
struct Config<'src> {
    hostname: &'src str,
    username: &'src str,
}

// The '_ lifetime parameter, in this case, refers to the anonymous lifetime attached to the type
// of the argument `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!("Parsed config: {:#?}", config);
}

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

Полиморфизм

Дженерики

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

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

use std::ops::Add;

// sum is a generic function with one type parameter, T
fn sum<T>(num1: T, num2: T) -> T
where  
    T: Add<Output = T>,  // T must implement the Add trait where addition returns another T
{
    num1 + num2  // num1 + num2 is syntactic sugar for num1.add(num2) provided by the Add trait
}

fn main() {
    let result1 = sum(10, 20);
    println!("Sum is: {}", result1); // Sum is: 30

    let result2 = sum(10.23, 20.45);
    println!("Sum is: {}", result2); // Sum is: 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 черта:

use std::fmt::Display;

let v: Vec<Box<dyn Display>> = vec![
    Box::new(3),
    Box::new(5.0),
    Box::new("hi"),
];

for x in v {
    println!("{x}");
}

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

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

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

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

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

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

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

Замыкания

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

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

|<parameter-name>: <type>| -> <return-type> { <body> };

Например:

let f = |x: i32| -> i32 { x * 2 };

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

let f = |x| { x * 2 };

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

let f = |x| x * 2;

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

let f = || println!("Hello, world!");

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

// A function which takes a function pointer as an argument and calls it with
// the value `5`.
fn apply(f: fn(i32) -> i32) -> i32 {
    // No semicolon, to indicate an implicit return
    f(5)
}

fn main() {
    // Defining the closure
    let f = |x| x * 2;

    println!("{}", apply(f));  // 10
    println!("{}", f(5));      // 10
}

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

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

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

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

// A function that takes a value of type F (which is defined as
// a generic type that implements the `Fn` trait, e.g. a closure)
// and calls it with the value `5`.
fn apply_by_ref<F>(f: F) -> i32
    where F: Fn(i32) -> i32
{
    f(5)
}

fn main() {
    let f = |x| {
        println!("I got the value: {}", x);
        x * 2
    };
    
    // Applies the function before printing its return value
    println!("5 * 2 = {}", apply_by_ref(f));
}

// ~~ Program output ~~
// I got the value: 5
// 5 * 2 = 10

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

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

Макросы

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

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

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

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

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

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

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

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

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

use serde::{Serialize, Deserialize};

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

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

    let serialized = serde_json::to_string(&point).unwrap();
    println!("serialized = {}", serialized);

    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
    println!("deserialized = {:?}", deserialized);
}

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

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

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

macro_rules! calculate {
    // The pattern for a single `eval`
    (eval $e:expr) => {{
        {
            let val: usize = $e; // Force types to be integers
            println!("{} = {}", stringify!{$e}, val);
        }
    }};

    // Decompose multiple `eval`s recursively
    (eval $e:expr, $(eval $es:expr),+) => {{
        calculate! { eval $e }
        calculate! { $(eval $es),+ }
    }};
}

fn main() {
    calculate! { // Look ma! Variadic `calculate!`!
        eval 1 + 2,
        eval 3 + 4,
        eval (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-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 .

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

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

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

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

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

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

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

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

Сообщество

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

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

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

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

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

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

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

Управленческие команды

Проект Rust состоит из команд , отвечающих за различные области разработки. Команда компилятора разрабатывает, управляет и оптимизирует внутренние компоненты компилятора; а языковая группа разрабатывает новые функции языка и помогает их реализовать. На сайте проекта Rust перечислены 6 команд высшего уровня по состоянию на июль 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 .

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

• Официальный сайт