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

Ржавчина

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

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

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

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

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

История

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

(

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

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

(2012–2020 гг

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn main() {
    // Defining a mutable variable with 'let mut'
    // Using the macro vec! to create a vector
    let mut values = vec![1, 2, 3, 4];

    for value in &values {
        println!("value = {}", value);
    }

    if values.len() > 5 {
        println!("List is longer than five items");
    }

    // Pattern matching
    match values.len() {
        0 => println!("Empty"),
        1 => println!("One value"),
        // pattern matching can use ranges of integers
        2..=10 => println!("Between two and ten values"),
        11 => println!("Eleven values"),
        // A `_` pattern is called a "wildcard", it matches any value
        _ => println!("Many values"),
    };

    // while loop with predicate and pattern matching using let
    while let Some(value) = values.pop() {
        println!("value = {value}"); // using curly brackets to format a local variable
    }
}

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

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

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

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

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

Замыкания

Этот раздел представляет собой отрывок из анонимной функции § 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 строго типизирован и статически типизирован . Типы всех переменных должны быть известны во время компиляции; присвоение значения определенного типа переменной другого типа приводит к ошибке компиляции . Переменные объявляются с помощью ключевого слова let, а вывод типа используется для определения их типа. Переменные, назначенные несколько раз, должны быть помечены ключевым словом mut (сокращение от изменяемого ).

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

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

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

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

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

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

Тип	Описание	Примеры
String	Строки в кодировке UTF-8 (динамические)	String::new() String::from("Hello") "🦀🦀🦀".to_string()
OsStr OsString	Собственные строки платформы (заимствованный и динамичный )	OsStr::new("Hello") OsString::from("world")
Path PathBuf	Пути (заимствованные и динамичный )	Path::new("./path/to") PathBuf::from(r"C:.\path\to")
CStr CString	C -совместимые строки с нулевым завершением (заимствованные и динамичный )	c"Hello" CStr::from_bytes_with_nul(b"Hello\0").unwrap() CString::new("world").unwrap()
Vec<T>	Динамические массивы	Vec::new() vec![1, 2, 3, 4, 5]
Option<T>	Тип опции	None Some(3) Some("hello")
Result<T, E>	Обработка ошибок с использованием типа результата	Ok(3) Err("something went wrong")
Box<T>	Указатель на значение, выделенное в куче . в 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.

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

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

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

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

Этот раздел представляет собой отрывок из Преобразование типов § 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 от использования за пределами своей области применения.

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

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

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,
}

// This function also has a lifetime parameter, 'cfg. 'cfg is attached to the "config" parameter, which
// establishes that the data in "config" lives at least as long as the 'cfg lifetime.
// The returned struct also uses 'cfg for its lifetime, so it can live at most as long as 'cfg.
fn parse_config<'cfg>(config: &'cfg str) -> Config<'cfg> {
    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 спроектирован так, чтобы быть безопасным для памяти . Он не допускает нулевых указателей, висячих указателей или гонок за данными . Значения данных могут быть инициализированы только с помощью фиксированного набора форм, каждая из которых требует, чтобы их входные данные были уже инициализированы.

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

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

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

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

Полиморфизм

Дженерики

Более продвинутые возможности 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 черта, это вызовет ошибку времени компиляции.

Итераторы

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

for x in 0..100 {
   f(x);
}

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

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

Макросы

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

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

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

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

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

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

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

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

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

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

use serde_json::{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 — Rust Analyzer , который официально заменил исходный языковой сервер RLS в июле 2022 года. Rust Analyzer предоставляет IDE и текстовым редакторам информацию о проекте Rust; базовые функции, включая автодополнение и отображение ошибок компиляции при редактировании.

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

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

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

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

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

Принятие

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

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

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

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

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

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

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

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

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

Сообщество

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

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

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

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

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

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

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

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

См. также

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

Ссылки

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

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

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

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

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

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