Перечисления и сопоставление — бесплатный тест онлайн

Вопрос 1 из 20

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

enum Message { Text(String), Move { x: i32, y: i32 }, Quit }
let m = Message::Move { x: 2, y: 3 };
let total = match m { Message::Move { x, y } => x + y, _ => 0 };
println!("{total}");

Заменить выражение с `Message` отдельным оператором и отбросить его значение, не меняя окружающий контракт «Перечисления enum». Заменить enum набором числовых кодов без отдельной проверки допустимых значений. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Перенести проверку результата `Message` на время выполнения и возвращать значение по умолчанию при несовпадении типов или ветвей. Добавить `mut` или явное приведение типа рядом с `Message`, сохранив прежнюю логику выражения и порядок вычислений. Моделировать взаимоисключающие состояния вариантами enum с нужными данными, а не набором флагов и необязательных полей.

Вопрос 2 из 20

Какой принцип Rust объясняет обычный сценарий для «Сопоставление match»?

If в Rust является только оператором управления и не может возвращать значение. По этой логике отдельная проверка «Сопоставление match» на другом входе считалась бы лишней. Pattern matching автоматически добавляет ветвь для всех пропущенных вариантов. По этой логике отдельная проверка «Сопоставление match» на другом входе считалась бы лишней. match проверяет шаблоны сверху вниз; guard является дополнительным условием ветви и не участвует в доказательстве исчерпывающей полноты. Match разрешено оставлять неисчерпывающим, если недостающие варианты редки. Поэтому ошибочный сценарий вокруг «Сопоставление match» не проверяли бы отдельно. Rust неявно приводит обе ветви выражения к общему динамическому типу. Проверку ошибки для «Сопоставление match» при таком подходе заменили бы успешным примером.

Вопрос 3 из 20

Что мешает этому фрагменту скомпилироваться?

enum Status { New, Running, Done }
fn label(s: Status) -> &'static str {
    match s {
        Status::New => "new",
        Status::Running => "running",
    }
}

Фрагмент успешно соберётся: pattern matching автоматически добавляет ветвь для всех пропущенных вариантов. Код не компилируется: вариант Status::Done не покрыт, а match должен быть исчерпывающим. Фрагмент успешно соберётся: все числовые литералы обязаны иметь явную аннотацию типа. Проверка типов пропустит этот путь: rust неявно приводит обе ветви выражения к общему динамическому типу. В результате `label` считали бы безопасным и на путях, которых пример не выполняет. Компилятор примет фрагмент: две ветви if используют разные имена локальных переменных.

Вопрос 4 из 20

Что важно понимать о механизме «Условное сопоставление if let», прежде чем менять код?

if let удобно для одного интересующего шаблона, но способ связывания полей по-прежнему определяет копирование, заимствование или перемещение. Match разрешено оставлять неисчерпывающим, если недостающие варианты редки. Тогда поведение «Условное сопоставление if let» при раннем выходе выводили бы из обычного пути. If в Rust является только оператором управления и не может возвращать значение. Следовательно, для «Условное сопоставление if let» не понадобилось бы явное предусловие. Частичное перемещение поля оставляет структуру целиком доступной для форматирования. Тогда поведение «Условное сопоставление if let» при раннем выходе выводили бы из обычного пути. Rust неявно приводит обе ветви выражения к общему динамическому типу. Следовательно, поведение `String::from` считалось бы одинаковым для всех допустимых типов.

Вопрос 5 из 20

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

После исчерпывающего match добавление нового варианта enum не требует пересмотра существующего кода. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Unicode не влияет на срезы строк, когда индекс визуально указывает на первый символ. По этой логике отдельная проверка «Перечисления enum» на другом входе считалась бы лишней. Порядок полей обычной структуры можно считать стабильным внешним форматом без repr. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Размер enum включает место для различителя и самого крупного варианта с учётом выравнивания; добавление большого варианта может увеличить все значения типа. Достаточно проверить один числовой вход: переполнение и преобразования не зависят от границ типа. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются.

Вопрос 6 из 20

Каков конечный результат операции `match`?

let value = Some(4);
let text = match value {
    Some(n) if n % 2 == 0 => "even",
    Some(_) => "odd",
    None => "none",
};
println!("{text}");

Такая запись допустима, так как pattern matching автоматически добавляет ветвь для всех пропущенных вариантов. По этой логике отдельная проверка `println!` на другом входе считалась бы лишней. Код компилируется, но пропущенный вариант match приводит к panic только при фактическом попадании в него. Код печатает even: сначала совпадает None(n), затем guard подтверждает чётность. Компиляция завершится успешно: rust неявно приводит обе ветви выражения к общему динамическому типу. Код печатает even: сначала совпадает Some(n), затем guard подтверждает чётность.

Вопрос 7 из 20

Какой узкий вывод следует из проверки `#[non_exhaustive]`?

#[non_exhaustive]
pub enum RemoteStatus { Ready, Busy }
// Во внешнем crate match обязан иметь wildcard-ветвь.

Отсутствие сообщения инструмента означает, что опасная ветвь была выполнена и признана корректной. Дополнительный сценарий вокруг `#[non_exhaustive]` при таком толковании уже не требуется. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Атрибут non_exhaustive предупреждает внешних пользователей о будущих вариантах и требует резервную ветвь при сопоставлении. Если обычный путь проходит, поведение при отмене и повторном входе можно считать следствием того же теста. Совпадение полного текста диагностики является главным и стабильным контрактом этой проверки. Дополнительный сценарий вокруг `#[non_exhaustive]` при таком толковании уже не требуется.

Вопрос 8 из 20

Что нужно проверить отдельно при переносе механизма «Сопоставление match» в библиотечный код?

Блоки обеих ветвей могут возвращать разные типы, если в текущем запуске выбирается только одна ветвь. Поэтому ошибочный сценарий вокруг «Сопоставление match» не проверяли бы отдельно. После исчерпывающего match добавление нового варианта enum не требует пересмотра существующего кода. Проверку ошибки для «Сопоставление match» при таком подходе заменили бы успешным примером. Unicode не влияет на срезы строк, когда индекс визуально указывает на первый символ. Guard может использовать связанные значения и отклонить совпавший шаблон, после чего проверка продолжится со следующей ветви. Индекс, равный длине массива, относится к последнему элементу и не является отдельным случаем.

Вопрос 9 из 20

Какое утверждение о механизме «Исчерпывающий разбор» можно переносить на другие примеры?

Rust неявно приводит обе ветви выражения к общему динамическому типу. Следовательно, для «Исчерпывающий разбор» не понадобилось бы явное предусловие. Shadowing изменяет значение прежней привязки и поэтому требует mut. Тогда поведение «Исчерпывающий разбор» при раннем выходе выводили бы из обычного пути. Pattern matching автоматически добавляет ветвь для всех пропущенных вариантов. If в Rust является только оператором управления и не может возвращать значение. Проверку ошибки для «Исчерпывающий разбор» при таком подходе заменили бы успешным примером. Компилятор проверяет исчерпывающий разбор enum и требует покрыть каждый возможный вариант либо общий шаблон.

Вопрос 10 из 20

Какое свойство закрепляет сценарий `String::from`?

let value = Some(String::from("ok"));
if let Some(text) = value.as_ref() { assert_eq!(text, "ok"); }
assert!(value.is_some());

as_ref преобразует &Option<String> в Option<&String>, поэтому содержимое не перемещается. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Дополнительный сценарий вокруг `String::from` при таком толковании уже не требуется. Тогда поведение `as_ref` при раннем выходе выводили бы из обычного пути. Положительный тест уже подтверждает все соседние состояния, поэтому отдельная матрица входов не требуется. Совпадение полного текста диагностики является главным и стабильным контрактом этой проверки.

Вопрос 11 из 20

Что Rust гарантирует при корректном использовании «Перечисления enum»?

Поле структуры нельзя переместить отдельно от остальных полей даже при владении всей структурой. Каждый вариант enum может иметь собственную форму данных; значение в каждый момент принадлежит ровно одному варианту. Match разрешено оставлять неисчерпывающим, если недостающие варианты редки. Такое рассуждение переносило бы вывод о «Перечисления enum» на неисполненную ветвь. Длина массива хранится рядом с данными во время выполнения и не входит в его тип. Контракт «Перечисления enum» считался бы одинаковым при любом состоянии входа. Оператор as всегда проверяет переполнение и возвращает Result при потере данных. Поэтому ошибочный сценарий вокруг «Перечисления enum» не проверяли бы отдельно.

Вопрос 12 из 20

Каков конечный результат операции `Message::Move`?

enum Message { Text(String), Move { x: i32, y: i32 }, Quit }
let m = Message::Move { x: 2, y: 3 };
let total = match m { Message::Move { x, y } => x + y, _ => 0 };
println!("{total}");

Проверка типов завершится ошибкой: кортеж содержит поле типа Copy рядом с владеющим полем. Код печатает 5: вариант перечисления хранит именованные данные, которые извлекаются шаблоном match. Компилятор отвергнет фрагмент, поскольку метод вызывается через точку, а не через полное имя типа. Компилятор отвергнет фрагмент, поскольку все числовые литералы обязаны иметь явную аннотацию типа. Ошибка возникнет на этапе компиляции: перечисления нельзя сопоставлять с guard-условиями.

Вопрос 13 из 20

Как исправить контракт, нарушенный при использовании `match`?

let value = Some(4);
let text = match value {
    Some(n) if n % 2 == 0 => "even",
    Some(_) => "odd",
    None => "none",
};
println!("{text}");

Добавить `mut` или явное приведение типа рядом с `text`, сохранив прежнюю логику выражения и порядок вычислений. Заменить выражение с `text` отдельным оператором и отбросить его значение, не меняя окружающий контракт «Сопоставление match». Оставить неохваченный вариант match и завершать программу через unreachable_unchecked(). Расположить более узкие шаблоны и guard до общего Some(_), сохранив отдельную ветвь None. Перенести проверку результата `text` на время выполнения и возвращать значение по умолчанию при несовпадении типов или ветвей.

Вопрос 14 из 20

Что можно считать доказанным после успешного выполнения `match`?

let x = Some(3);
let y = match x { Some(n) if n > 5 => n, Some(n) => n * 2, None => 0 };
assert_eq!(y, 6);

Раз тест прошёл, производительность решения тоже можно считать подтверждённой. Отсутствие сообщения инструмента означает, что опасная ветвь была выполнена и признана корректной. Совпадение полного текста диагностики является главным и стабильным контрактом этой проверки. Успешная ветвь служит достаточным доказательством поведения при ошибке и повторном выполнении. Первая ветвь совпадает по форме, но guard ложен; управление переходит к следующему Some(n).

Вопрос 15 из 20

Что можно считать доказанным после успешного выполнения `size_of`?

use std::mem::size_of;
enum State { Empty, Number(u64), Bytes([u8; 32]) }
println!("{}", size_of::<State>());

Проверка размера показывает цену самого крупного варианта и различителя, но конкретное число нельзя превращать в стабильный внешний формат без repr. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Дополнительный сценарий вокруг `std::mem::size_of` при таком толковании уже не требуется. Положительный тест уже подтверждает все соседние состояния, поэтому отдельная матрица входов не требуется. Тогда поведение `std::mem` при раннем выходе выводили бы из обычного пути. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Дополнительный сценарий вокруг `std::mem::size_of` при таком толковании уже не требуется. Отсутствие сообщения инструмента означает, что опасная ветвь была выполнена и признана корректной. Дополнительный тест другого состояния при таком толковании уже не требуется. Такое рассуждение переносило бы вывод о `std::mem` на неисполненную ветвь.

Вопрос 16 из 20

К какому результату приводит последовательность вокруг `String::from`?

let value = Some(String::from("ok"));
if let Some(text) = value {
    println!("{text}");
}
// println!("{value:?}");

До выполнения код дойдёт без ошибки компиляции, поскольку частичное перемещение поля оставляет структуру целиком доступной для форматирования. Внутри ветви строка копируется из value; последующее использование value целиком не компилировалось бы. Внутри ветви строка перемещается из value; последующее использование value целиком не компилировалось бы. Rust не примет такую запись, поскольку две ветви if используют разные имена локальных переменных. Такая запись допустима, так как rust неявно приводит обе ветви выражения к общему динамическому типу. Поэтому ошибочный сценарий вокруг `String::from` не проверяли бы отдельно.

Вопрос 17 из 20

Как привести работу с `String::from` в соответствие с правилами Rust?

let value = Some(String::from("ok"));
if let Some(text) = value {
    println!("{text}");
}
// println!("{value:?}");

Добавить as-приведение в каждой ветви, даже если оно может молча потерять данные. Заменить выражение с `String::from` отдельным оператором и отбросить его значение, не меняя окружающий контракт «Условное сопоставление if let». Если значение нужно позже, сопоставлять ссылку: if let Some(text) = &value или использовать value.as_ref(). Перенести проверку результата `String::from` на время выполнения и возвращать значение по умолчанию при несовпадении типов или ветвей. Добавить `mut` или явное приведение типа рядом с `String::from`, сохранив прежнюю логику выражения и порядок вычислений.

Вопрос 18 из 20

Что нужно проверить отдельно при переносе механизма «Условное сопоставление if let» в библиотечный код?

После исчерпывающего match добавление нового варианта enum не требует пересмотра существующего кода. Следовательно, для «Условное сопоставление if let» не понадобилось бы явное предусловие. Краткая форма незаметно игнорирует остальные варианты; когда пропуск состояния является ошибкой домена, полный match делает контракт заметнее. Частичное перемещение поля не влияет на возможность использовать структуру целиком. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Порядок полей обычной структуры можно считать стабильным внешним форматом без repr. Индекс, равный длине массива, относится к последнему элементу и не является отдельным случаем. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются.

Вопрос 19 из 20

Какая правка выдержит ревью контракта «Исчерпывающий разбор»?

enum Status { New, Running, Done }
fn label(s: Status) -> &'static str {
    match s {
        Status::New => "new",
        Status::Running => "running",
    }
}

Добавить as-приведение в каждой ветви, даже если оно может молча потерять данные. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Из этого следовало бы, что иной порядок операций для `label` ничего не меняет. Перенести проверку результата `Status` на время выполнения и возвращать значение по умолчанию при несовпадении типов или ветвей. Добавить `mut` или явное приведение типа рядом с `Status`, сохранив прежнюю логику выражения и порядок вычислений. Добавить явную ветвь Done; wildcard использовать только когда объединение оставшихся вариантов действительно является частью контракта. Заменить выражение с `Status` отдельным оператором и отбросить его значение, не меняя окружающий контракт «Исчерпывающий разбор».

Вопрос 20 из 20

Какое изменение входа способно поменять вывод о механизме «Исчерпывающий разбор»?

Unicode не влияет на срезы строк, когда индекс визуально указывает на первый символ. Тогда поведение «Исчерпывающий разбор» при раннем выходе выводили бы из обычного пути. После исчерпывающего match добавление нового варианта enum не требует пересмотра существующего кода. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Контракт «Исчерпывающий разбор» считался бы одинаковым при любом состоянии входа. Индекс, равный длине массива, относится к последнему элементу и не является отдельным случаем. Тогда поведение «Исчерпывающий разбор» при раннем выходе выводили бы из обычного пути. Блоки обеих ветвей могут возвращать разные типы, если в текущем запуске выбирается только одна ветвь. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Тогда поведение «Исчерпывающий разбор» при раннем выходе выводили бы из обычного пути. Широкая ветвь _ упрощает добавление новых вариантов, но может скрыть изменение поведения; явные ветви заставляют пересмотреть код при расширении enum.