Rust Core

У публичной структуры одно поле объявлено без pub: что именно сможет и чего не сможет сделать код из другого crate?

Что требует Rust от шаблона параметра функции, чтобы вызов всегда был допустим?

Что меняется в семантике владения, когда значение сопоставляют с шаблоном _, а не связывают именем?

Вызов обобщённой функции не даёт контекста ни в аргументах, ни в ожидаемом результате: почему Rust не выводит параметр типа?

Почему два параметра функции, записанные через impl Trait, не обязаны иметь один и тот же конкретный тип?

Почему шаблон с .. в массиве сохраняет фиксированное число элементов, а в срезе может соответствовать произвольному количеству?

Атрибут repr(u8) у перечисления: какую гарантию о представлении он даёт, но не фиксирует размер всего значения?

При передаче уже имеющейся изменяемой ссылки в функцию с параметром того же типа почему исходная ссылка обычно остаётся доступной после вызова?

Выход из области видимости: в каком порядке Rust уничтожает локальные переменные с реализацией Drop?

Какую роль играет расходящееся ветвление else в конструкции let-else Rust?

В цикле Rust несколько break передают значения разных типов: что произойдёт при компиляции?

При объявлении обобщённой структуры как Copy какое требование Rust предъявляет к её полям?

Зачем параметру типа явно указывать ограничение ?Sized, если ссылка уже может указывать на значение динамически определяемого размера?

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

При сопоставлении структуры шаблон с ..: какие поля он оставляет несвязанными и как это влияет на владение?

Вызов функции с аргументом типа, реализующего Copy: почему после вызова исходное имя остаётся доступным?

Можно ли хранить значение типа dyn Trait непосредственно в локальной переменной, и какой механизм определяет допустимый способ хранения?

Разберите, какой тип имеют add_one и pointer и почему оба значения можно передать в apply.

fn add_one(x: i32) -> i32 {
    x + 1
}

fn apply(f: fn(i32) -> i32, x: i32) -> i32 {
    f(x)
}

fn main() {
    let item = add_one;
    let pointer: fn(i32) -> i32 = add_one;
    println!("{} {}", apply(item, 4), apply(pointer, 5));
}

От чего зависит совместимость двух замыканий с одинаковой сигнатурой в Rust?

В чём различие между объявлением модуля и импортом его имени через use в Rust?