Типы, переменные и shadowing — бесплатный тест онлайн

Вопрос 1 из 20

Какое свойство «Кортежи» сохранится после небольшого рефакторинга?

Shadowing изменяет тип уже существующей переменной без создания новой привязки. Контракт «Кортежи» считался бы одинаковым при любом состоянии входа. Частичное перемещение поля оставляет структуру целиком доступной для форматирования. Следовательно, для «Кортежи» не понадобилось бы явное предусловие. Shadowing изменяет значение прежней привязки и поэтому требует mut. Проверку ошибки для «Кортежи» при таком подходе заменили бы успешным примером. Метод с &self получает независимую копию объекта и может свободно менять его поля. Такое рассуждение переносило бы вывод о «Кортежи» на неисполненную ветвь. Поля кортежа могут перемещаться или копироваться независимо в зависимости от их типов и способа шаблонного связывания.

Вопрос 2 из 20

Как устранить исходную ошибку, связанную с `String::from`?

let pair = (String::from("id"), 7u32);
let (name, count) = pair;
println!("{name}:{count}");

Если кортеж нужен и после разбора, деструктурировать по ссылке: let (name, count) = (&pair.0, pair.1); либо сопоставлять &pair. Скрыть различие типов за строковым форматированием и затем разобрать значение обратно. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Добавить `mut` или явное приведение типа рядом с `pair`, сохранив прежнюю логику выражения и порядок вычислений. Заменить выражение с `pair` отдельным оператором и отбросить его значение, не меняя окружающий контракт «Кортежи». Перенести проверку результата `pair` на время выполнения и возвращать значение по умолчанию при несовпадении типов или ветвей.

Вопрос 3 из 20

Что нужно изменить вокруг `parse`, чтобы устранить первопричину?

let value = "41";
let value: i32 = value.parse().unwrap();
let value = value + 1;
println!("{value}");

Заменить выражение с `i32` отдельным оператором и отбросить его значение, не меняя окружающий контракт «Повторное связывание имён». Оставить shadowing, если этапы преобразования образуют одну логическую величину; разные сущности лучше назвать по-разному, чтобы не скрыть ошибку. Использовать wrapping-арифметику для любого переполнения, даже когда переполнение означает ошибку входных данных. Добавить `mut` или явное приведение типа рядом с `i32`, сохранив прежнюю логику выражения и порядок вычислений. Перенести проверку результата `i32` на время выполнения и возвращать значение по умолчанию при несовпадении типов или ветвей.

Вопрос 4 из 20

Чем завершится фрагмент, посвящённый механизму «Массивы»?

let a = [3; 4];
let b: [i32; 3] = [3, 3, 3];
println!("{} {}", a.len(), b.len());

Компиляция закончится диагностикой: кортеж содержит поле типа Copy рядом с владеющим полем. Фрагмент не соберётся: все числовые литералы обязаны иметь явную аннотацию типа. Проверку ошибки для `len` при таком подходе заменили бы успешным примером. Компиляция завершится успешно: выход за границы массива возвращает None независимо от используемой операции. Такое рассуждение переносило бы вывод о `len` на неисполненную ветвь. Код печатает 4 3: длина является частью типа массива, а синтаксис [value; count] повторяет значение count раз. Код пройдёт проверку компилятора: rust неявно приводит обе ветви выражения к общему динамическому типу.

Вопрос 5 из 20

Какой дефект способен воспроизвести тест `String::from`?

let pair = (String::from("x"), 9u32);
let first = pair.0;
println!("{}", pair.1);

Положительный тест уже подтверждает все соседние состояния, поэтому отдельная матрица входов не требуется. Тогда поведение `String::from` при раннем выходе выводили бы из обычного пути. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Отсутствие сообщения инструмента означает, что опасная ветвь была выполнена и признана корректной. Фрагмент компилируется: pair.0 перемещён, но отдельное Copy-поле pair.1 остаётся доступным; использовать pair целиком уже нельзя. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно.

Вопрос 6 из 20

Какое правило связывает типы и наблюдаемое поведение в механизме «Скалярные типы»?

Оператор as всегда проверяет переполнение и возвращает Result при потере данных. По этой логике отдельная проверка «Скалярные типы» на другом входе считалась бы лишней. Rust неявно приводит обе ветви выражения к общему динамическому типу. Из этого следовало бы, что иной порядок операций для «Скалярные типы» ничего не меняет. If в Rust является только оператором управления и не может возвращать значение. Выход за границы массива возвращает None независимо от используемой операции. Следовательно, поведение `checked_add` считалось бы одинаковым для всех допустимых типов. Целочисленные методы checked_*, wrapping_*, saturating_* и overflowing_* задают поведение переполнения явно и устраняют зависимость от настроек проверок.

Вопрос 7 из 20

Какое предусловие «Повторное связывание имён» необходимо записать явно?

Unicode не влияет на срезы строк, когда индекс визуально указывает на первый символ. Следовательно, для «Повторное связывание имён» не понадобилось бы явное предусловие. Блоки обеих ветвей могут возвращать разные типы, если в текущем запуске выбирается только одна ветвь. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Достаточно проверить один числовой вход: переполнение и преобразования не зависят от границ типа. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Поэтому ошибочный сценарий вокруг «Повторное связывание имён» не проверяли бы отдельно. Новая привязка начинает жить с точки объявления, а прежняя может быть освобождена, если больше не нужна; shadowing способен влиять на момент Drop. Индекс, равный длине массива, относится к последнему элементу и не является отдельным случаем. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение.

Вопрос 8 из 20

Какой вывод допустим после запуска `&mut` и чего он не доказывает?

struct Trace(&'static str);
impl Drop for Trace { fn drop(&mut self) { println!("{}", self.0); } }
let item = Trace("old");
let item = Trace("new");
println!("body");

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

Вопрос 9 из 20

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

Shadowing изменяет значение прежней привязки и поэтому требует mut. Тогда поведение «Повторное связывание имён» при раннем выходе выводили бы из обычного пути. If в Rust является только оператором управления и не может возвращать значение. Поэтому ошибочный сценарий вокруг «Повторное связывание имён» не проверяли бы отдельно. Shadowing изменяет тип уже существующей переменной без создания новой привязки. Следовательно, поведение `parse` считалось бы одинаковым для всех допустимых типов. Метод с &self получает независимую копию объекта и может свободно менять его поля. Следовательно, поведение `parse` считалось бы одинаковым для всех допустимых типов. Shadowing создаёт новую привязку и может менять тип или изменяемость; это не то же самое, что присваивание существующей переменной.

Вопрос 10 из 20

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

let max: u8 = 255;
println!("{:?}", max.checked_add(1));

Добавить `mut` или явное приведение типа рядом с `max`, сохранив прежнюю логику выражения и порядок вычислений. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Если переполнение является ошибкой данных, обработать None или использовать checked_add(...).ok_or(...); wrapping_add уместен только при явно циклической арифметике. Использовать wrapping-арифметику для любого переполнения, даже когда переполнение означает ошибку входных данных. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Заменить конкретные типы на Box<dyn Any> и выполнять все проверки приведением во время выполнения. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Заменить выражение с `max` отдельным оператором и отбросить его значение, не меняя окружающий контракт «Скалярные типы».

Вопрос 11 из 20

Какое условие способно превратить рабочий пример «Скалярные типы» в ошибочный?

Индекс, равный длине массива, относится к последнему элементу и не является отдельным случаем. Проверку ошибки для «Скалярные типы» при таком подходе заменили бы успешным примером. Блоки обеих ветвей могут возвращать разные типы, если в текущем запуске выбирается только одна ветвь. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Следовательно, для «Скалярные типы» не понадобилось бы явное предусловие. Unicode не влияет на срезы строк, когда индекс визуально указывает на первый символ. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Следовательно, для «Скалярные типы» не понадобилось бы явное предусловие. Обычный оператор + при переполнении может вести себя по-разному в сборках с включёнными и выключенными overflow-checks, поэтому на его панику нельзя опираться как на универсальный контракт. Достаточно проверить один числовой вход: переполнение и преобразования не зависят от границ типа. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. По этой логике отдельная проверка «Скалярные типы» на другом входе считалась бы лишней.

Вопрос 12 из 20

Как переписать реализацию без лишней копии и скрытого предусловия?

let a = [3; 4];
let b: [i32; 3] = [3, 3, 3];
println!("{} {}", a.len(), b.len());

Добавить `mut` или явное приведение типа рядом с `i32`, сохранив прежнюю логику выражения и порядок вычислений. Такое рассуждение переносило бы вывод о `len` на неисполненную ветвь. Заменить выражение с `i32` отдельным оператором и отбросить его значение, не меняя окружающий контракт «Массивы». Перенести проверку результата `i32` на время выполнения и возвращать значение по умолчанию при несовпадении типов или ветвей. Следовательно, для `len` не понадобилось бы явное предусловие. Заменить конкретные типы на Box<dyn Any> и выполнять все проверки приведением во время выполнения. Если функции нужны массивы разных длин, принимать срез &[T] либо использовать const generic параметр N, а не фиксировать одну длину.

Вопрос 13 из 20

Чем завершится выполнение фрагмента с `String::from`?

let pair = (String::from("id"), 7u32);
let (name, count) = pair;
println!("{name}:{count}");

Код компилируется: деструктуризация копирует String и копирует u32 из кортежа, после чего используются новые привязки. Этот фрагмент будет отклонён: кортеж содержит поле типа Copy рядом с владеющим полем. Такое рассуждение переносило бы вывод о `String::from` на неисполненную ветвь. Rust примет этот код, поскольку shadowing изменяет тип уже существующей переменной без создания новой привязки. Код компилируется: деструктуризация перемещает String и копирует u32 из кортежа, после чего используются новые привязки. Сборка пройдёт, поскольку частичное перемещение поля оставляет структуру целиком доступной для форматирования.

Вопрос 14 из 20

Какую регрессию должен ловить `saturating_add`?

assert_eq!(250u8.saturating_add(20), 255);
assert_eq!(250u8.wrapping_add(20), 14);

Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Результат можно считать доказательством свойства языка, даже если он зависит от конкретной библиотеки или платформы. Дополнительный сценарий вокруг `saturating_add` при таком толковании уже не требуется. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Дополнительный сценарий вокруг `saturating_add` при таком толковании уже не требуется. Проверка показывает разные намерения: saturating_add ограничивает результат максимумом, а wrapping_add выполняет арифметику по модулю 256. Совпадение полного текста диагностики является главным и стабильным контрактом этой проверки. Соседние ветви ошибки, отмены и частичного выполнения тогда считают проверенными автоматически. Такое рассуждение переносило бы вывод о `saturating_add` на неисполненную ветвь.

Вопрос 15 из 20

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

let value = "41";
let value: i32 = value.parse().unwrap();
let value = value + 1;
println!("{value}");

Проверка типов пропустит этот путь: shadowing изменяет тип уже существующей переменной без создания новой привязки. Проверка типов пропустит этот путь: pattern matching автоматически добавляет ветвь для всех пропущенных вариантов. Код компилируется и печатает 42: каждое let создаёт новую привязку с тем же именем, причём тип может измениться. Такая запись допустима, так как rust неявно приводит обе ветви выражения к общему динамическому типу. Rust не примет такую запись, поскольку две ветви if используют разные имена локальных переменных. Такое рассуждение переносило бы вывод о `parse` на неисполненную ветвь.

Вопрос 16 из 20

Какое правило связывает типы и наблюдаемое поведение в механизме «Массивы»?

Выход за границы массива возвращает None независимо от используемой операции. Контракт «Массивы» считался бы одинаковым при любом состоянии входа. Rust неявно приводит обе ветви выражения к общему динамическому типу. Поэтому ошибочный сценарий вокруг «Массивы» не проверяли бы отдельно. Длина массива хранится рядом с данными во время выполнения и не входит в его тип. Следовательно, для «Массивы» не понадобилось бы явное предусловие. Тип массива записывается [T; N], где N известна при компиляции; срез &[T] хранит длину во время выполнения и может ссылаться на массивы разных размеров. If в Rust является только оператором управления и не может возвращать значение. Следовательно, поведение `i32` считалось бы одинаковым для всех допустимых типов.

Вопрос 17 из 20

Какой вывод о выполнении `checked_add` подтверждает код?

let max: u8 = 255;
println!("{:?}", max.checked_add(1));

Код компилируется, но переполнение целого всегда даёт одно и то же значение во всех профилях сборки. До выполнения код дойдёт без ошибки компиляции, поскольку выход за границы массива возвращает None независимо от используемой операции. Код печатает None: checked_add сообщает о переполнении через Result и не зависит от профиля сборки. Этот фрагмент будет отклонён: две ветви if используют разные имена локальных переменных. Поэтому ошибочный сценарий вокруг `checked_add` не проверяли бы отдельно. Код печатает None: checked_add сообщает о переполнении через Option и не зависит от профиля сборки.

Вопрос 18 из 20

Какой граничный случай важнее всего учесть для механизма «Кортежи»?

Блоки обеих ветвей могут возвращать разные типы, если в текущем запуске выбирается только одна ветвь. В результате «Кортежи» считали бы безопасным и на путях, которых пример не выполняет. Частичное перемещение из кортежа делает недоступным кортеж целиком, но оставшиеся неперемещённые Copy-поля могут по-прежнему читаться напрямую. Частичное перемещение поля не влияет на возможность использовать структуру целиком. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Достаточно проверить один числовой вход: переполнение и преобразования не зависят от границ типа. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Такое рассуждение переносило бы вывод о «Кортежи» на неисполненную ветвь. Unicode не влияет на срезы строк, когда индекс визуально указывает на первый символ. Контракт «Кортежи» считался бы одинаковым при любом состоянии входа.

Вопрос 19 из 20

Как правильно истолковать результат проверки механизма «Массивы»?

let a = [10, 20, 30];
assert_eq!(a.get(3), None);

Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Достаточно убедиться, что пример компилируется; наблюдаемое поведение отдельной проверки не требует. Следовательно, для `get` не понадобилось бы явное предусловие. get безопасно сообщает об отсутствии элемента через None и не вызывает панику при индексе, равном длине массива. Совпадение полного текста диагностики является главным и стабильным контрактом этой проверки.

Вопрос 20 из 20

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

Блоки обеих ветвей могут возвращать разные типы, если в текущем запуске выбирается только одна ветвь. Из этого следовало бы, что иной порядок операций для «Массивы» ничего не меняет. Достаточно проверить один числовой вход: переполнение и преобразования не зависят от границ типа. Тогда поведение «Массивы» при раннем выходе выводили бы из обычного пути. Индекс с известным во время выполнения значением всё равно проверяется на границы; выход за длину приводит к панике, а get возвращает Option. Индекс, равный длине массива, относится к последнему элементу и не является отдельным случаем. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Такое рассуждение переносило бы вывод о «Массивы» на неисполненную ветвь. Unicode не влияет на срезы строк, когда индекс визуально указывает на первый символ. В результате «Массивы» считали бы безопасным и на путях, которых пример не выполняет.