Обобщения и ограничения — бесплатный тест онлайн

Вопрос 1 из 25

Как завершится обычная ветвь выполнения после `std::fmt::Display`?

fn compare_and_show<T, U>(a: &T, b: &U) -> String
where
    T: PartialEq<U> + std::fmt::Display,
    U: std::fmt::Display,
{
    format!("{a} {} {b}", if a == b { "=" } else { "!=" })
}

Такая запись допустима, так как dyn Trait сохраняет конкретный размер значения внутри типа указателя без косвенности. Код пройдёт проверку компилятора: blanket impl автоматически разрешает любые пересечения реализаций. Проверка типов завершится ошибкой: ограничение записано в where-секции. До последней строки и наблюдаемого результата программа при таком разборе не доходит. Фрагмент не соберётся: конкретный тип реализует несколько независимых трейтов. Сигнатура разрешает сравнивать разные типы T и U, если T реализует PartialEq<U>, и форматировать оба значения.

Вопрос 2 из 25

Как завершится обычная ветвь выполнения после `String::from`?

fn identity<T>(x: T) -> T { x }
let a = identity(10u32);
let b = identity(String::from("x"));

Проверка типов пропустит этот путь: обобщённая функция использует один общий машинный код с динамическим поиском всех методов. Код компилируется, но мономорфизация выбирает реализацию при каждом вызове через таблицу имён. Значит, выполнение должно пройти через `String::from` без изменения сигнатуры. Компилятор создаёт специализированный машинный код для реально используемых подстановок identity<u32> и identity<String>, если оптимизация не объединит или не встроит их. Rust примет этот код, поскольку dyn Trait сохраняет конкретный размер значения внутри типа указателя без косвенности. Компилятор примет фрагмент: trait bound проверяется только при фактическом вызове метода во время выполнения.

Вопрос 3 из 25

Что может сломаться при другом размере входа или порядке действий в «Где-условия»?

Ассоциированный тип и параметр типа взаимозаменяемы для всех контрактов вызывающего кода. Если generic-код компилируется для одного типа, скрытые ограничения для других типов невозможны. Граница на T не переносится на &T автоматически во всех контекстах; нужно учитывать, для какого именно типа реализован используемый трейт. Один вызов замыкания подтверждает, что оно реализует Fn и может вызываться повторно. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Добавление метода в публичный трейт не влияет на существующие реализации пользователей.

Вопрос 4 из 25

Какую регрессию должен ловить «Generic-типы»?

let numbers = Pair { left: 1u8, right: 2u8 };
let words = Pair { left: "a", right: "b" };

Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Дополнительный сценарий вокруг «Generic-типы» при таком толковании уже не требуется. Два значения имеют разные мономорфизированные типы Pair<u8> и Pair<&str>; это не один runtime-контейнер с динамическим типом. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Одного успешного примера достаточно, чтобы считать проверенными и невыполненные ветви контракта. Тогда различия между обычным и граничным случаем для «Generic-типы» исчезли бы. Отсутствие сообщения инструмента означает, что опасная ветвь была выполнена и признана корректной.

Вопрос 5 из 25

Что может сломаться при другом размере входа или порядке действий в «Generic-типы»?

Поля Pair<T> обязаны иметь один и тот же T; для разных типов нужны Pair<L, R> или enum, а вывод типа не создаёт скрытого преобразования. Переход с impl Trait на dyn Trait не меняет владение, layout и стоимость вызова. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Если generic-код компилируется для одного типа, скрытые ограничения для других типов невозможны. Один вызов замыкания подтверждает, что оно реализует Fn и может вызываться повторно. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Ассоциированный тип и параметр типа взаимозаменяемы для всех контрактов вызывающего кода. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются.

Вопрос 6 из 25

Что должно войти в отрицательный тест механизма «Тестирование и инструменты Cargo»?

Один вызов замыкания подтверждает, что оно реализует Fn и может вызываться повторно. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Тогда различия между обычным и граничным случаем для «Тестирование и инструменты Cargo» исчезли бы. Один тест с i32 не проверяет поведение для несized, заимствованных и пользовательских типов; набор подстановок выбирают по различающимся контрактам, а не по количеству. Если generic-код компилируется для одного типа, скрытые ограничения для других типов невозможны. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Добавление метода в публичный трейт не влияет на существующие реализации пользователей. Ассоциированный тип и параметр типа взаимозаменяемы для всех контрактов вызывающего кода. Тогда поведение «Тестирование и инструменты Cargo» при раннем выходе выводили бы из обычного пути.

Вопрос 7 из 25

К какому результату приводит последовательность операций в этом коде?

trait Draw { fn draw(&self) -> String; }
fn render_all(items: &[Box<dyn Draw>]) -> Vec<String> {
    items.iter().map(|x| x.draw()).collect()
}

Фрагмент успешно соберётся: обобщённая функция использует один общий машинный код с динамическим поиском всех методов. Компиляция завершится успешно: blanket impl автоматически разрешает любые пересечения реализаций. Срез хранит разнородные значения за trait object и вызывает draw динамически через таблицу виртуальных функций. Компиляция завершится успешно: dyn Trait сохраняет конкретный размер значения внутри типа указателя без косвенности. Код компилируется, но нарушение trait bound вызывает panic только на неподходящем значении.

Вопрос 8 из 25

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

trait Draw { fn draw(&self) -> String; }
fn render_all(items: &[Box<dyn Draw>]) -> Vec<String> {
    items.iter().map(|x| x.draw()).collect()
}

Выбирать dyn Trait для разнородной коллекции или стабильной границы компиляции; generic T: Trait — для однородных типов и статической диспетчеризации. Продублировать реализацию для каждого известного типа вокруг `Draw`, вместо того чтобы исправить границы обобщения «Выбор абстракции». Клонировать захваченное состояние перед каждым вызовом `Draw`, не уточняя требуемый трейт вызова или время жизни. Заменить текущую форму `Draw` на `Box<dyn Trait>` во всех местах, не проверяя владение, объектобезопасность и стоимость вызова. Добавить Clone ко всем trait bounds, даже если реализация использует только ссылки. При каждом таком вызове появляется отдельный владелец и оплачивается копирование данных.

Вопрос 9 из 25

Что именно стало проверяемым благодаря сценарию `compare_and_show`?

assert_eq!(compare_and_show(&5i32, &5i32), "5 = 5");

Успешный запуск подтверждает корректность не только этого пути, но и остальных ветвей программы. Дополнительный сценарий вокруг `compare_and_show` при таком толковании уже не требуется. Контракт считается покрытым после обычного запуска; различия при отмене и частичном результате несущественны. Тест подтверждает не только компиляцию границ, но и выбор ветви сравнения и форматирование результата. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Раз тест прошёл, производительность решения тоже можно считать подтверждённой. Дополнительный сценарий вокруг `compare_and_show` при таком толковании уже не требуется.

Вопрос 10 из 25

Какая часть механизма «Выбор абстракции» зафиксирована тестом `draw`?

fn render_one(item: &impl Draw) -> String { item.draw() }

Отсутствие сообщения инструмента означает, что опасная ветвь была выполнена и признана корректной. Нормальный результат на одном входе позволяет распространить тот же вывод на отмену и частичное выполнение. Тогда различия между обычным и граничным случаем для `render_one` исчезли бы. impl Draw в аргументе означает отдельный статически известный тип на каждый вызов функции, а не произвольный trait object. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно.

Вопрос 11 из 25

Какая правка выдержит ревью контракта «Где-условия»?

fn compare_and_show<T, U>(a: &T, b: &U) -> String
where
    T: PartialEq<U> + std::fmt::Display,
    U: std::fmt::Display,
{
    format!("{a} {} {b}", if a == b { "=" } else { "!=" })
}

Использовать where для сложных взаимосвязей и связанных типов; не заменять точное ограничение более сильным одинаковым T без требования задачи. Продублировать реализацию для каждого известного типа вокруг `compare_and_show`, вместо того чтобы исправить границы обобщения «Где-условия». Дублировать реализацию для каждого типа вместо выражения минимального содержательного ограничения. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Заменить текущую форму `compare_and_show` на `Box<dyn Trait>` во всех местах, не проверяя владение, объектобезопасность и стоимость вызова. Клонировать захваченное состояние перед каждым вызовом `compare_and_show`, не уточняя требуемый трейт вызова или время жизни.

Вопрос 12 из 25

Какая правка выдержит ревью контракта «Мономорфизация»?

fn identity<T>(x: T) -> T { x }
let a = identity(10u32);
let b = identity(String::from("x"));

Сохранять статическую обобщённость там, где важны инлайнинг и отсутствие виртуального вызова; при чрезмерном росте кода оценить dyn Trait или внутреннюю не generic-функцию. Клонировать захваченное состояние перед каждым вызовом `identity`, не уточняя требуемый трейт вызова или время жизни. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Добавить Clone ко всем trait bounds, даже если реализация использует только ссылки. При каждом таком вызове появляется отдельный владелец и оплачивается копирование данных. Тогда различия между обычным и граничным случаем для `identity` исчезли бы. Заменить текущую форму `identity` на `Box<dyn Trait>` во всех местах, не проверяя владение, объектобезопасность и стоимость вызова. Продублировать реализацию для каждого известного типа вокруг `identity`, вместо того чтобы исправить границы обобщения «Мономорфизация».

Вопрос 13 из 25

Какой принцип лежит в основе механизма «Generic-типы»?

Мономорфизация создаёт один общий вариант функции и хранит типовой тег рядом со значением. Любой трейт можно использовать как dyn Trait без ограничений на методы и Self. Контракт «Generic-типы» считался бы одинаковым при любом состоянии входа. Обобщённая функция использует один общий машинный код с динамическим поиском всех методов. Поэтому ошибочный сценарий вокруг «Generic-типы» не проверяли бы отдельно. Dyn Trait сохраняет конкретный размер значения внутри типа указателя без косвенности. Следовательно, поведение `String::from` считалось бы одинаковым для всех допустимых типов. Параметр типа позволяет одной структуре хранить разные конкретные типы, а методы могут работать только средствами, доступными без дополнительных bounds.

Вопрос 14 из 25

Какое утверждение о «Мономорфизация» остаётся верным при смене входных данных?

Dyn Trait сохраняет конкретный размер значения внутри типа указателя без косвенности. Тогда различия между обычным и граничным случаем для «Мономорфизация» исчезли бы. Trait bound проверяется только при фактическом вызове метода во время выполнения. Trait bounds проверяются при выполнении, когда конкретный метод впервые вызван. Тогда различия между обычным и граничным случаем для «Мономорфизация» исчезли бы. Мономорфизация превращает generic-код в конкретные реализации на этапе компиляции и обычно не требует хранения runtime-описания T. Мономорфизация создаёт один общий вариант функции и хранит типовой тег рядом со значением. Такое рассуждение переносило бы вывод о «Мономорфизация» на неисполненную ветвь.

Вопрос 15 из 25

Какой риск остаётся после успешной компиляции кода по теме «Выбор абстракции»?

Один вызов замыкания подтверждает, что оно реализует Fn и может вызываться повторно. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Тогда поведение «Выбор абстракции» при раннем выходе выводили бы из обычного пути. Не каждый трейт совместим с dyn: методы, возвращающие Self или имеющие собственные generic-параметры без ограничений, могут нарушать dyn compatibility. Добавление метода в публичный трейт не влияет на существующие реализации пользователей. Следовательно, для «Выбор абстракции» не понадобилось бы явное предусловие. Переход с impl Trait на dyn Trait не меняет владение, layout и стоимость вызова. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Из этого следовало бы, что иной порядок операций для «Выбор абстракции» ничего не меняет. Если generic-код компилируется для одного типа, скрытые ограничения для других типов невозможны. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение.

Вопрос 16 из 25

Что отделяет корректное применение «Тестирование и инструменты Cargo» от случайно работающего решения?

Trait bounds проверяются при выполнении, когда конкретный метод впервые вызван. Тогда различия между обычным и граничным случаем для «Тестирование и инструменты Cargo» исчезли бы. Мономорфизация создаёт один общий вариант функции и хранит типовой тег рядом со значением. По этой логике отдельная проверка «Тестирование и инструменты Cargo» на другом входе считалась бы лишней. Where-секция меняет смысл ограничений по сравнению с записью после параметра типа. Тогда различия между обычным и граничным случаем для «Тестирование и инструменты Cargo» исчезли бы. Отрицательные сценарии generic-ограничений удобно закреплять compile_fail doctest или специализированными UI-тестами, а обычные unit-тесты охватывают только компилируемые подстановки. Любой трейт можно использовать как dyn Trait без ограничений на методы и Self.

Вопрос 17 из 25

Какой рефакторинг исправляет причину сбоя возле `&mut`?

/// ```compile_fail
/// let x: Vec<_> = vec![1, 2];
/// let _a = &mut x[0];
/// let _b = &mut x[1];
/// ```
pub struct BorrowRules;

Для generic-API проверять runtime-поведение на нескольких типах и compile-fail случаи для недопустимых bounds; сообщения компилятора не следует сравнивать целиком. Заменить текущую форму `compile_fail` на `Box<dyn Trait>` во всех местах, не проверяя владение, объектобезопасность и стоимость вызова. Клонировать захваченное состояние перед каждым вызовом `compile_fail`, не уточняя требуемый трейт вызова или время жизни. Добавить Clone ко всем trait bounds, даже если реализация использует только ссылки. При каждом таком вызове появляется отдельный владелец и оплачивается копирование данных. Контракт «Тестирование и инструменты Cargo» считался бы одинаковым при любом состоянии входа. Продублировать реализацию для каждого известного типа вокруг `compile_fail`, вместо того чтобы исправить границы обобщения «Тестирование и инструменты Cargo».

Вопрос 18 из 25

Какое состояние получится после всех действий с `String::from`?

struct Pair<T> { left: T, right: T }
impl<T> Pair<T> {
    fn swap(self) -> Self { Self { left: self.right, right: self.left } }
}
let p = Pair { left: String::from("a"), right: String::from("b") }.swap();

Код компилируется: swap перемещает оба поля внутри нового Pair<T> и не требует ни Clone, ни Copy. Проверка типов пропустит этот путь: обобщённая функция использует один общий машинный код с динамическим поиском всех методов. Поэтому ошибочный сценарий вокруг `swap` не проверяли бы отдельно. Код компилируется: swap копирует оба поля внутри нового Pair<T> и не требует ни Clone, ни Copy. Фрагмент успешно соберётся: blanket impl автоматически разрешает любые пересечения реализаций. Фрагмент успешно соберётся: dyn Trait сохраняет конкретный размер значения внутри типа указателя без косвенности.

Вопрос 19 из 25

Что система типов не проверит самостоятельно для механизма «Мономорфизация»?

Переход с impl Trait на dyn Trait не меняет владение, layout и стоимость вызова. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Размер машинного кода не меняется при росте числа мономорфизаций. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Ассоциированный тип и параметр типа взаимозаменяемы для всех контрактов вызывающего кода. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Такое рассуждение переносило бы вывод о «Мономорфизация» на неисполненную ветвь. Добавление метода в публичный трейт не влияет на существующие реализации пользователей. Такое рассуждение переносило бы вывод о «Мономорфизация» на неисполненную ветвь. Zero-cost не означает нулевой размер бинарника или нулевое время компиляции: множество подстановок может увеличить код и длительность сборки.

Вопрос 20 из 25

Какое объяснение механизма «Где-условия» не смешивает компиляцию и выполнение?

Trait bounds проверяются при выполнении, когда конкретный метод впервые вызван. Следовательно, поведение `std::fmt::Display` считалось бы одинаковым для всех допустимых типов. where-условия эквивалентны кратким bounds, но лучше выражают несколько параметров, lifetime-связи и ограничения на associated types. Where-секция меняет смысл ограничений по сравнению с записью после параметра типа. Тогда различия между обычным и граничным случаем для «Где-условия» исчезли бы. Blanket impl автоматически разрешает любые пересечения реализаций. Dyn Trait сохраняет конкретный размер значения внутри типа указателя без косвенности. Из этого следовало бы, что иной порядок операций для «Где-условия» ничего не меняет.

Вопрос 21 из 25

Что именно стало проверяемым благодаря сценарию `String::from`?

fn identity<T>(x: T) -> T { x }
let a = identity(10u32);
let b = identity(String::from("x"));

# cargo bloat или анализ nm/objdump для release-сборки
# сравнить число специализаций до и после вынесения общего тела

Нормальный результат на одном входе позволяет распространить тот же вывод на отмену и частичное выполнение. По этой логике отдельная проверка `identity` на другом входе считалась бы лишней. Отсутствие сообщения инструмента означает, что опасная ветвь была выполнена и признана корректной. Сравнение символов и размера release-бинарника показывает фактическую цену мономорфизации; один исходный generic-метод может породить несколько экземпляров. Успешный запуск подтверждает корректность не только этого пути, но и остальных ветвей программы. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Тогда различия между обычным и граничным случаем для `identity` исчезли бы.

Вопрос 22 из 25

Что важно понимать о механизме «Выбор абстракции», прежде чем менять код?

Мономорфизация создаёт один общий вариант функции и хранит типовой тег рядом со значением. Тогда различия между обычным и граничным случаем для «Выбор абстракции» исчезли бы. Dyn Trait сохраняет конкретный размер значения внутри типа указателя без косвенности. Тогда различия между обычным и граничным случаем для «Выбор абстракции» исчезли бы. Любой трейт можно использовать как dyn Trait без ограничений на методы и Self. Следовательно, поведение `map` считалось бы одинаковым для всех допустимых типов. impl Trait и generic bounds дают статическую диспетчеризацию, а dyn Trait стирает конкретный тип и использует fat pointer с динамическим вызовом. Trait bounds проверяются при выполнении, когда конкретный метод впервые вызван. Следовательно, поведение `map` считалось бы одинаковым для всех допустимых типов.

Вопрос 23 из 25

Какую гарантию даёт `&mut`, а какую нужно проверять отдельно?

/// ```compile_fail
/// let x: Vec<_> = vec![1, 2];
/// let _a = &mut x[0];
/// let _b = &mut x[1];
/// ```
pub struct BorrowRules;

Код пройдёт проверку компилятора: dyn Trait сохраняет конкретный размер значения внутри типа указателя без косвенности. Такая запись допустима, так как ограничение записано в where-секции. Значит, выполнение должно пройти через `&mut` без изменения сигнатуры. Код считается допустимым, потому что обобщённая функция использует один общий машинный код с динамическим поиском всех методов. Doctest compile_fail считается успешным, когда пример не компилируется; он фиксирует ожидаемое ограничение API или языка. Сборка пройдёт, поскольку blanket impl автоматически разрешает любые пересечения реализаций.

Вопрос 24 из 25

Как правильно прочитать результат диагностического сценария `&mut`?

/// ```compile_fail
/// let x: Vec<_> = vec![1, 2];
/// let _a = &mut x[0];
/// let _b = &mut x[1];
/// ```
pub struct BorrowRules;

# cargo test --doc
# cargo test --test public_generics

Для этого сценария достаточно проверки сборки: результат выполнения не входит в проверяемый контракт. Результат можно считать доказательством свойства языка, даже если он зависит от конкретной библиотеки или платформы. Дополнительный сценарий вокруг `&mut` при таком толковании уже не требуется. Отсутствие сообщения инструмента означает, что опасная ветвь была выполнена и признана корректной. Дополнительный сценарий вокруг `&mut` при таком толковании уже не требуется. Один положительный сценарий покрывает контракт целиком, включая частичный результат и преждевременное завершение. Такое рассуждение переносило бы вывод о «Тестирование и инструменты Cargo» на неисполненную ветвь. Первая команда проверит compile-fail документацию, вторая — внешний публичный generic-API из каталога tests.

Вопрос 25 из 25

Что исправить вокруг `String::from`, чтобы граничный вход обрабатывался безопасно?

struct Pair<T> { left: T, right: T }
impl<T> Pair<T> {
    fn swap(self) -> Self { Self { left: self.right, right: self.left } }
}
let p = Pair { left: String::from("a"), right: String::from("b") }.swap();

Клонировать захваченное состояние перед каждым вызовом `Pair`, не уточняя требуемый трейт вызова или время жизни. Не добавлять ограничения к impl, пока операции обходятся перемещением; границы размещать на тех методах, которым они действительно нужны. Добавить Clone ко всем trait bounds, даже если реализация использует только ссылки. При каждом таком вызове появляется отдельный владелец и оплачивается копирование данных. Заменить текущую форму `Pair` на `Box<dyn Trait>` во всех местах, не проверяя владение, объектобезопасность и стоимость вызова. Продублировать реализацию для каждого известного типа вокруг `Pair`, вместо того чтобы исправить границы обобщения «Generic-типы».