Структуры данных:
Типы данных и ячейки памяти, определенные с помощью ключевых слов.
struct S {} - определение структуры с именованными полями.
struct S { x: T }- определение структуры с именованным полем X типа T.struct S (T);- определение структуры «tupled» с нумерованным полем .0 типа T.struct S;- определение структуры блока NOM нулевого размера. Не занимает места, оптимизировано.
enum E {} - определение перечисления, с алгебраическими типами данных, помещенных в объединение.
enum E { A, B(), C{} }- опрределяет варианты перечисления; может быть unit-A, tuple-B() и структурноподобным C{}.enum E { A = 1 }- если варианты являются только единичными, допустимы дискриминантные значения, например, для FFI.enum E {}- варианты enum неопределены, ссылка не может быть создана, это ‘never’.
union U {} - небезопасное C-образное соединение ссылки для совместимости FFI.
static X: T = T(); - глобальная переменная со статическим временем жизни, одна ячейка памяти.
const X: T = T(); - определяет константу, определяется как временная при использовании.
let x: T; - выделяет T байт на стеке, именнуется как x. Назначается один раз, не может изменяться.
let mut x: T; - выделяет T байт на стеке, именнуется как x. Допускают мутабельность и изменяемое заимствование.
x = y; - перемещает y в x, что делает y недействительным, если значение не является копируемым типом.
Создание структур данных и доступ к ним; и некоторые типы.
S { x: y } - создаёт структуру S{} или использует перечисление E::S{} с полем x, равным значению y.
S { x } - то же самое, но использует локальную переменную x для поля x.
S { ..s } - заполняет оставшиеся поля из s, полезно с помощью Default::default().
S { 0: x } - как и S(x) ниже, но задается полем .0 с синтаксисом struct.
S (x) - создаёт структуру S(T) или использует перечисление E::S(), в поле .0 которого установлено значение x.
S - если S - блочная структура то S; или использует enum E::S создаёт значение S.
E::C { x: y } - создаёт вариант перечисления C. Другие методы, описанные выше, также работают.
() - пустой кортеж, как литерал, так и тип, он же блок.
(x) - выражение в скобках.
(x,) - одноэлементное выражение кортежа.
(S,) - тип одноэлементного кортежа.
[S] - тип массива неопределенной длины, т.е. фрагмент. Не может работать в стеке.
[S; n] - Массив фиксированной длины n содержащий элементы типа S.
[x; n] - экземпляр ссылки массива (выражение) с n копиями в x.
[x, y] - экземпляр массива с заданными элементами x и y.
x[0] - Индексация коллекции, здесь в квадратных скобках usize. Реализуется с Index, IndexMut.
x[..] - То же самое, через диапазон (это полный диапазон).
a..b - создаёт диапазон, например, 1..3 содержит 1, 2.
..b - диапазон без начальной точки.
..=b - включающий b диапазон без начальной точки.
a..=b - включающий b диапазон, 1..=3 означает 1, 2, 3.
a.. - диапазон без конечной точки.
.. - полный диапазон, обычно означает всю коллекцию.
s.x - доступ к именованному полю, ссылка может попытаться выполнить команду Deref, если x не является частью типа S.
s.0 - пронумерованный доступ к полю, используемый для кортежей S(T).
Ссылки и указатели
Предоставление доступа к памяти.
&S - общая ссылка (тип; пространство для хранения любых &s).
&[S]- специальная ссылка на фрагмент, содержащая (адрес, количество).&str- специальная ссылка на фрагмент строки, которая содержит (адрес, количество байтов).&mut S- исключительная ссылка на возможность изменения (&mut [S], & mut dyn S,…).&dyn T- ссылка на объект специального контейнера, содержащая (адрес, таблицу).
&s - совместное заимствование (например, адрес, длина, таблица,… это s как 0x1234).
&mut s- исключительное заимствование, допускающее возможность изменения.
*const S - неизменяемый тип необработанного указателя без безопасности памяти.
*mut S- изменяемый тип необработанного указателя без безопасности памяти.&raw const s- создаёт необработанный указатель без перехода через ссылку; ptr:addr_of!().&raw mut s- то же самое, но изменяемое. Raw ptrs. необходимы для неориентированных упакованных полей.
ref s - привязывает по ссылке, делает привязку ссылочным типом.
let ref r = s;- эквивалентно r = &s.let S { ref mut x } = s;- изменяемая ссылка (let x = &mut s.x), сокращенная деструктивная версия.
*r - ссылка r для доступа к значению, на которое указывает.
*r = s;- если r является изменяемой ссылкой, перемещает или копирует s в r.s = *r;- делает s копией любых r ссылок, если это тип имеет Copy.s = *r;- не будет работать, если *r не имеет Copy, так как это переместится и будет пустое значение.s = *my_box;- особый случай для Box, который также может перемещать содержимое, не являющееся копией.
'a - параметр времени жизни, длительность потока в статическом анализе.
&'a S- то же самое, но разрешает изменение содержимого адреса.struct S<'a> {}- сигнализирует, что S будет содержать адрес с временем жизни ‘a. Создать S разрешает ‘a.trait T<'a> {}- сигнализирует, что любой S, которые подразумевают T для S, может содержать адрес.fn f<'a>(t: &'a T)- сигнализирует, что эта функция обрабатывает некоторый адрес. Решение принимает ‘a.'static- специальное время жизни, продолжающееся все время выполнения программы.
Функции и поведение
Определяет единицы кода и их абстракции.
trait T {} - определяет trait; Общие типы поведения BK EX REF могут соответствовать.
trait T : R {} - T - subtrait для supertrait R. Любая S должна иметь impl R, прежде чем она сможет иметь impl T.
impl S {} - реализация функциональных возможностей для типа S, например, методов.
impl T for S {} - реализация trait Т для типа S; указывает, как именно S действует, в Т.
impl !T for S {} - отключает производную trait T для типа S.
fn f() {} - определяет функцию или метод внутри impl.
fn f() -> S {}- то же самое, возвращая значение типа S.fn f(&self) {}- определяет метод, например, в пределах impl S {}.
struct S (T); - определяет функцию конструктора fn S(x: T) -> S.
const fn f() {} - константа fn, используемая во время компиляции, например, const X: u32 = f (Y).
async fn f() {} - асинхронная функция, делает возврат из impl Future.
async fn f() -> S {}- то же самое, но выполнить функцию f и вернуть impl Future <Output = S>.async { x }- Используйте функцию, чтобы сделать {x} impl Future<Output = X>.
fn() -> S - указатель функции, адрес хранения в памяти вызываемого устройства.
Fn() -> S - вызываемая trait (также FnMut, FnOnce), реализованна закрытиями функций…
|| {} - функция замыкания.
|x| {}- замыкание, принимающее один аргумент с именем x, тело является блочным выражением.|x| x + x- то же самое, без блочного выражения; может состоять только из одного выражения.move |x| x + y- перемещает значение в замыкание в его собственность; то есть Y передается в замыкание.return || true- замыкания иногда выглядят как логические OR (здесь: вернуть замыкание).
unsafe - если вам нравится отладка; небезопасный код.
unsafe fn f() {}- означает «вызов может вызвать небезопасную функцию, ВЫ должны проверить ее требования».unsafe trait T {}- означает “небезопасный impl. Т может вызывать ошибку; исполнитель должен проверить “.unsafe { f(); }- гарантии компилятору «Я проверил требования, поверь мне».unsafe impl T for S {}- гарантии S, хорошо себя ведет T; люди могут безопасно использовать T на S.
Поток управления
Управление выполнением в функции
while x {} - цикл, выполняется, пока выражение x имеет значение true.
loop {} - бесконечный цикл до break. Может давать значение с break x.
for x in collection {} - синтаксический сахар цикл по итератору.
collection.into_iter()- преобразует любой тип в соответствующий итератор.iterator.next()- перебирает итератор, x = next() до исчерпания (первый None).
if x {} else {} - Условная ветвь, если выражение имеет значение true.
'label: {} - метка блока, может использоваться для выхода из этого блока.
'label: loop {} - аналогичная метка цикла, полезна для управления потоком во вложенных циклах.
break - Разорвать выражение для выхода из блока или цикла.
break 'label x- переходит из блока или цикла на метку с именем «label» и возращает значение x.break 'label- то же самое, но не ни чего не возврвщвет.break x- установливает значение x при выходе из самого внутреннего цикла (только в реальном цикле).
continue - продолжает выполнение следующей итерации этого цикла.
continue 'label - то же самое, но вместо этого цикла, переходит в верхний цикл, помеченный «label».
x? - Если x равно Err или None, возвращает значение из функции или метода.
x.await - Синтаксический сахар, чтобы получить future, poll, yield. Работает только в асинхронном режиме.
x.into_future()- преобразует любой тип IntoFuture в future.future.poll()- при Future выполняет poll() и поток yield, если Poll::Pending.
return x - возвращение из функции. Более идиоматичным является завершение выражением.
{ return }- выход из функции.|| { return }- выход из замыкания.async { return }- выход из асинхронной функции.
f() - вызывает f (например, функцию, замыкание, указатель функции, Fn,…).
x.f() - вызов метода, принимает self, &self,… в качестве первого аргумента.
X::f(x)- аналогично x.f(). Только impl Copy для X {}, f можно вызвать только один раз.X::f(&x)- аналогично x.f().X::f(&mut x)- аналогично x.f().S::f(&x)- то же, что и x.f(), если X дерефируется в S, т.е. x.f() находит методы S.T::f(&x)- аналогично x.f(), если X impl T, т.е. x.f() находит методы T, если в области видимости.
X::f() - вызов связанной функцию, например, X::new().
<X as T>::f()- вызывает trait метод T::f(), реализованный для X.
Организационный код
Сегментирование проектов на более мелкие единицы и минимизирование зависимостей.
mod m {} - определяет модуль, получает определение изнутри {}.
mod m; - определяет модуль, получает определение из m.rs или m/mod.rs.
a::b - путь к пространству имен к элементу b в пределах (mod, enum,…).
::b- поиск b в корне модуля или внешней прелюдии; глобальный путь.crate::b- поиск b в корне.self::b- поиск b в текущем модуле.super::b- поиск b в родительском модуле.
use a::b; - использовать непосредственно в этом модуле.
use a::{b, c}; - то же самое, но включить b и c в модуль.
use a::b as x; - включить b в модуль, но по имени x, например, использовать std::error::Error as E.
use a::b as _; - приводит b анонимно в модуль, полезно для trait с конфликтующими именами.
use a::*; - включает все из a, рекомендуется, если a является какой-то прелюдией.
pub use a::b; - включает a::b в модуль для реэкспорта.
pub T - публичное значение, родительский путь является общедоступным для T.
pub(crate) T- виден в текущем модуле.pub(super) T- виден в родительском модуле.pub(self) T- виден в текущем модуле (по умолчанию, как и без pub).pub(in a::b) T- виден у предка a::b.
extern crate a; - объявить зависимость от внешнего модуля; просто используйте a::b.
extern "C" {} - объявить внешние зависимости и ABI (например, «C») из FFI.
extern "C" fn f() {} - определить функцию для экспорта с ABI (например, «C») в FFI.
Псевдонимы и составные части типа
Краткие имена типов и методы преобразования одного типа в другой.
type T = S; - создает псевдоним типа, т.е. другое имя для S.
Self - псевдоним типа для реализующего типа, например, fn new() -> Self.
self - Объект метода в fn f(self) {}, например, сродни fn f(self: Self) {}.
&self- то же самое, но относится к себе как к заимствованию, будет равно f(self: &Self).&mut self- то же, но заимствование мутабельно, будет равен f(self: &mut Self).self: Box<Self>- произвольный самостоятельный тип, добавление методов к интеллектуальным указателям (my_box.f_of_self()).
<S as T> - определяет тип S как trait T, например, <S as T >::f().
a::b as c - при использовании импортирует b как c, например, use a::b as c.
x as u32 - примитивное преобразование типа, может усекаться и быть немного неожиданным.
Макросы и атрибуты
Конструкции генерации кода расширяются до фактической компиляции.
m!() - вызов макроса, также m!{}, m![] (в зависимости от макроса).
#[attr] - внешний атрибут, аннотирование следующего элемента.
#![attr] - внутренний атрибут, аннотирующий верхний окружающий элемент.
$x:ty - захват макросов,:… фрагмент определяет, что разрешено для $x.
$x - подстановка макросов, например, использует захваченный $x:ty сверху.
$(x),* - повторение макросов 0 или более раз в макросах на примере.
$(x),?- то же самое, но ноль или один раз.$(x),+- то же самое, но один или несколько раз.$(x)<<+- также принимаются сепараторы, отличные от.
Паттерн Match
Конструкции в выражениях соответствия или разрешения или параметрах функции.
match m {} - сопоставление шаблонов, используются команды match arms, из таблицы ниже.
let S(x) = get(); - аналогично таблице ниже.
let S { x } = s;- x будет привязан к значению s.x.let (_, b, _) = abc;- b будет привязан к значению abc.1.let (a, ..) = abc;- игнорировать остальное.let (.., a, b) = (1, 2);- привязки имеют приоритет над остальными, здесь a равно 1, b равно 2.let s @ S { x } = get();- привязка s к S при привязке x к s.x, привязка шаблона.let w @ t @ f = get();- сохраняет 3 копии результата get() в каждой w, t, f.let (|x| x) = get();- не замыкание, то же, что и let x = get ();
let Some(x) = get(); - не будет работать, если шаблон будет опровергнут, используйте let else или if let вместо этого.
let Some(x) = get() else {}; - делать, если возможно, if not else {}, обычно break, return, panic!,…
if let Some(x) = get() {} - ветвь, если шаблон может быть назначен (например, вариант перечисления), синтаксический сахар.
while let Some(x) = get() {} - продолжает вызывать get() в цикле до тех пор, пока шаблон может быть назначен.
fn f(S { x }: S) - параметры функции также работают, здесь x привязана к s.x из f(s).
Совпадающие элементы шаблона в выражениях соответствия. Левую часть этого также можно найти в выражениях let.
E::A => {} - шаблон варианта перечисления A, совпадение шаблонов.
E::B ( .. ) => {} - шаблон варианта кортежа перечисления B, игнорирует любой индекс.
E::C { .. } => {} - шаблон варианта структуры перечисления C, игнорирует любое поле.
S { x: 0, y: 1 } => {} - шаблон структуры с определенными значениями (принимает только s.x 0 и s.y 1).
S { x: a, y: b } => {} - шаблон структуры с любыми значениями связывает s.x с a и s.y с b.
S { x, y } => {}- то же самое, но коротко с s.x и s.y, связанны как x и y соответственно.
S { .. } => {} - шаблон структуры с любыми значениями.
D => {} - шаблон варианта перечисления E::D, если D используется.
D => {} - шаблон что угодно, связать D; возможно, ложный вариант E::D, если D не используется.
_ => {} - шаблон «все остальное».
0 | 1 => {} - альтернативные патерны.
E::A | E::Z => {}- то же самое, но на вариантах перечисления.E::C {x} | E::D {x} => {}- то же самое, но использовать x, если он есть у всех вариантов.Some(A | B) => {}- то же самое, может также совпадать с глубоко вложенными альтернативами.|x| x => {}- паттерн, ведущий | игнорируется, используется только x | x, следовательно x.
(a, 0) => {} - шаблон кортеж с любым значением для а и 0.
[a, 0] => {} - шаблон среза, соответствует массиву с любым значением для a и 0.
[1, ..] => {}- шаблон массив, начинающийся с 1, дальше любое значение.[1, .., 5] => {}- образец массив, начиная с 1, заканчивая 5.[1, x @ .., 5] => {}- то же самое, но также привязать x к срезу, представляющему середину.[a, x @ .., b] => {}- то же самое, но соответствует любому первому, последнему, как a, b соответственно.
1 .. 3 => {} - шаблон диапазона, здесь соответствует 1 и 2.
1 ..= 3 => {}- шаблон диапазона, соответствует 1, 2 и 3.1 .. => {}- шаблон диапазона, совпадающий с 1 и любым большим числом.
x @ 1..=5 => {} - шаблон соответствует x; привязка шаблона, здесь x будет 1, 2,… или 5.
Err(x @ Error {..}) => {}- работает вложенно, здесь x привязывается к Error.
S { x } if x > 10 => {} - защита соответствия шаблона, условие также должно быть true.
Дженерики и ограничения
Дженерики сочетаются с конструкторами типов, traits и функциями, что дает пользователям больше гибкости.
struct S<T> … - универсальный тип с параметром типа (T здесь является именем типа).
S<T> where T: R - trait типы допускаются T, T имеет свойство R; R должно быть в trait.
where T: R, P: S- типы trait, здесь один для T и один для P.where T: R, S- ошибка компиляции. Вероятно, необходимо создать составную привязку R + S см. ниже.where T: R + S- trait типы T должны соответствовать R и S.where T: R + 'a- то же самое, но со временем жизни. Т должен выполнять R, если Т имеет время жизни ‘а.where T: ?Sized- отказаться от предварительно определенной границы trait, это размер.where T: 'a- ограничение время жизни типа; если у T есть ссылки, они должны пережить ‘a.where T: 'static- то же самое; не означает, что значение t будет жить в static.where 'b: 'a- время жизни ‘b должно быть по крайней мере столько сколько и ‘a.where u8: R<T>- позволяет делать условные операторы с участием других типов.
S<T: R> - короткая запись, почти такая же, как и выше.
S<const N: usize> - generic const; значение типа S может предоставить константу N.
S<10>- при использовании в качестве примитивных значений может быть указан предел значения.S<{5+5}>- выражения должны быть заключены в фигурные скобки.
S<T = R> - параметры по умолчанию; делает S немного проще в использовании, но сохраняет его гибкость.
S<const N: u8 = 0>- параметр по умолчанию для констант; например, в f(x: S) {} параметр N равен 0.S<T = u8>- параметр по умолчанию для типов, например, в f(x: S) {} параметр T - u8.
S<'_> - предполагаемое анонимное время жизни; просит компилятор «разобраться», если это очевидно.
S<_> - анонимный тип, например let x: Vec<_> = iter.collect ().
S::<T> - значения типа, например, f::<u32>().
trait T<X> {} - дженерик X. Может иметь несколько impl T для S (по одному на X).
trait T { type X; } - определяет связанный тип X. Возможен только один impl T для S.
trait T { type X<G>; } - определяет универсальный связанный тип (GAT), например, X может быть универсальным Vec<>.
trait T { type X<'a>; } - определяет базовую модель GAT в течение всего срока службы.
type X = R;- задать связанный тип в пределах impl T for S {type X = R;}.type X<G> = R<G>;- то же самое для GAT, например, impl T for S {type X<G> = Vec<G>;}.
impl<T> S<T> {} - реализует метод для любого T в S<T>, здесь T тип параметра.
impl S<T> {} - реализует метод для S<T>, здесь T специфический тип, например, u8.
fn f() -> impl T - экзистенциальные типы, возвращает неизвестное вызывающему S, который предполагает Т.
fn f(x: &impl T) - trait связанный через «impl traits», несколько похожий на fn f<S:T>(x: & S).
fn f(x: &dyn T) - вызов f посредством динамической вызова, f не будет создан для x.
fn f<X: T>(x: X) - универсальная функция над X, f будет создана («мономорфизирована») для каждого X.
fn f() where Self: R; - в trait T {} сделать f доступным только для типов, известных также как impl R.
fn f() where Self: Sized;- с помощью параметра размера можно отключить параметр f от параметра dyn T trait объекта vtable, включив параметр trait obj.fn f() where Self: R {}- другие R полезные методы.
Другие выражения
Реальные типы и trait, абстрактные над чем-то, с периодом жизни.
for<'a> - маркер для более дальних границ периода жизни.
trait T: for<'a> R<'a> {}- любая S, которая предполагает Т, также должна будет выполнять R в течение любого срока службы.
fn(&'a u8) - тип указателя функции, содержащий fn, вызываемый с определенным временем жизни «a».
for<'a> fn(&'a u8) - ранжированный тип, содержащий fn, вызываемый с любым lt.; подтип выше см.
fn(&'_ u8)- то же самое; автоматически расширяется до типа для <‘a> fn(&‘a u8).fn(&u8)- то же самое; автоматически расширяется до типа для <‘a> fn(&‘a u8).
dyn for<'a> Fn(&'a u8) - тип с более высоким рангом (признак-объект), работает как fn выше.
dyn Fn(&'_ u8)- то же самое; автоматическое расширение до типа dyn for<‘a> Fn(&‘a u8).dyn Fn(&u8)- то же самое; автоматическое расширение до типа dyn for<‘a> Fn(&‘a u8).
impl<'a> T for fn(&'a u8) {} - для функции указатель, где вызов принимает определенные lt. ‘a, impl trait Т.
impl T for for<'a> fn(&'a u8) {} - для функции указатель, где вызов принимает любой lt., impl trait Т.
impl T for fn(&u8) {}- то же, короткая версия.
Строки и символы
У Rust есть несколько способов создания строк.
"..." - строковый литерал, UTF-8.
"\n\r\t\0\\"- ескейп символы, например, «\n» переход на новую строку."\x36"- ASCII. До 7f, например, «\x36» станет 6."\u{7fff}"- юникод. До 6 цифр, например, «\u {7fff} »становится 翿.
r"..." - литерал необработанной строки, UTF-8, не интерпретирует ескейп символы.
r#"..."# - строковый литерал, UTF-8, но может содержать символы “. Количество символов # может варьироваться.
b"..." - строковый литерал байта; создает последовательность ASCII [u8], а не строку.
br"...", br#"..."# - строковый литерал необработанного байта, ASCII [u8], комбинация вышеперечисленного.
'🦀' - символьный литерал, фиксированный 4-байтовый юникод «char».
b'x' - литерал байта ASCII, один байт u8.
Документация
Отладчики невидят его. Избегайте ошибок с этим странным трюком.
/// - комментарий в документе внешней линии, используйте их для типов, traits, функций,…
//! - комментарий в документе внутренней строки, в основном используемый в начале файла для модуля документов.
// - комментарий строки, используйте для документирования кода или внутренних устройств.
/* … */ - блочный комментарий.
/** … */ - комментарий в документе внешнего блока.
/*! … */ - комментарий в документе внутреннего блока.
Разное
Эти сигилы не подходили ни к одной другой категории, но, тем не менее, хорошо это знать.
! - всегда пустой never тип.
fn f() -> ! {}- функция, которая никогда не возвращается с любым типом, например, let x: u8 = f();fn f() -> Result<(), !> {}- функция, которая должна возвращать результат, но сигнализирует о том, что она никогда не сможет вернуть ошибку.fn f(x: !) {}- функция, которая существует, но не может быть вызвана. Не очень полезно.
_ - неименованная подстановочная переменная, например, | x, _| {}.
let _ = x;- неназванное назначение - no-op, не перемещается из области x или не сохраняет область!_ = x;- можно присвоить _ все, что угодно, без разрешения, т.е. _ = ignore_error();
_x - привязка к переменной явно помечена как неиспользуемая.
1_234_567 - числовой разделитель для наглядности.
1_u8 - спецификатор типа для числовых литералов (также i8, u16,…).
0xBEEF, 0o777, 0b1001 - шестнадцатеричные (0x), восьмеричные (0o) и двоичные (0b) целочисленные литералы.
r#foo - необработанный идентификатор для совместимости версий.
x; - оператор окончания выражения.
Общие операторы
Rust поддерживает большинство операторов (+, *,%, =, =,…), включая перегрузку. Поскольку они ведут себя также в Rust, мы не перечисляем их здесь.