Option и отсутствие значения — бесплатный тест онлайн

Вопрос 1 из 20

Где заканчивается гарантия обычного сценария для «Безопасное извлечение»?

Успешный happy path достаточен: ветви Err и None не меняют владение и освобождение ресурсов. Тогда поведение «Безопасное извлечение» при раннем выходе выводили бы из обычного пути. Если функция возвращает Result, она не может оставить частично изменённое состояние. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Контракт «Безопасное извлечение» считался бы одинаковым при любом состоянии входа. unwrap_or вычисляет аргумент заранее, а unwrap_or_else вызывает замыкание только для None; различие важно при дорогих вычислениях и побочных эффектах. Текст ошибки можно сравнивать дословно во всех версиях зависимостей и локалях. Тогда поведение «Безопасное извлечение» при раннем выходе выводили бы из обычного пути. Отмена между побочным эффектом и повтором не создаёт риска дублирования операции. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Такое рассуждение переносило бы вывод о «Безопасное извлечение» на неисполненную ветвь.

Вопрос 2 из 20

Какой результат даст фрагмент о механизме «Преобразование Option через map»?

let value: Option<String> = None;
let len = value.map(|s| s.len());
println!("{len:?}");

Код не пройдёт проверку: option требует отдельного null-указателя в памяти для каждого значения. Проверку ошибки для `map` при таком подходе заменили бы успешным примером. Компиляция закончится диагностикой: result нельзя возвращать из обычной функции без async. Код печатает None, а замыкание не вызывается: map преобразует только содержимое Some. Код компилируется, но none и Err различаются только форматом печати, но не управлением выполнением. Rust примет этот код, поскольку map и and_then одинаково устраняют вложенный Option или Result.

Вопрос 3 из 20

Какой эксплуатационный край отличает контракт «Преобразование Option через map» от удачного примера?

map по Option<String> потребляет сам Option и может переместить String; для сохранения исходного значения сначала использовать as_ref или as_deref. Ошибки данных и инфраструктуры можно объединить в один вариант без последствий для восстановления. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Если функция возвращает Result, она не может оставить частично изменённое состояние. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Успешный happy path достаточен: ветви Err и None не меняют владение и освобождение ресурсов. Такое рассуждение переносило бы вывод о «Преобразование Option через map» на неисполненную ветвь. Отмена между побочным эффектом и повтором не создаёт риска дублирования операции. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. В результате «Преобразование Option через map» считали бы безопасным и на путях, которых пример не выполняет.

Вопрос 4 из 20

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

let configured: Option<u16> = None;
let port = configured.unwrap_or_else(|| 8080);
println!("{port}");

Код печатает 8080: запасное значение вычисляется немедленно только для None. Проверка типов завершится ошибкой: option требует отдельного null-указателя в памяти для каждого значения. Такая запись допустима, так как unwrap превращает любой Err или None в значение, используя Default. Код печатает 8080: запасное значение вычисляется лениво только для None. Код компилируется, но none и Err различаются только форматом печати, но не управлением выполнением. Поэтому ошибочный сценарий вокруг `unwrap_or_else` не проверяли бы отдельно.

Вопрос 5 из 20

Какое изменение окружения может повлиять на вывод о «Some и None»?

Для некоторых ссылок и ненулевых типов Option использует нишевую оптимизацию и может не увеличивать размер, но это не универсальная гарантия для любого T. Если функция возвращает Result, она не может оставить частично изменённое состояние. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Контракт «Some и None» считался бы одинаковым при любом состоянии входа. Отмена между побочным эффектом и повтором не создаёт риска дублирования операции. Текст ошибки можно сравнивать дословно во всех версиях зависимостей и локалях. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Успешный happy path достаточен: ветви Err и None не меняют владение и освобождение ресурсов. Поэтому ошибочный сценарий вокруг «Some и None» не проверяли бы отдельно.

Вопрос 6 из 20

Что исправляет не симптом, а саму ошибку вокруг `parse`?

fn parse_port(s: &str) -> Option<u16> { s.parse().ok() }
let result = Some("8080").and_then(parse_port);
println!("{result:?}");

При ошибке `parse_port` возвращать значение по умолчанию, не сообщая вызывающему коду причину и возможность восстановления. Использовать and_then для зависимых шагов T -> Option<U>; map уместен, когда следующий шаг всегда выдаёт обычное U. Заменить обработку результата `parse_port` на `unwrap` или `expect`, сохранив прежний возвращаемый тип функции. Считать этот отказ нарушением внутреннего инварианта и использовать `panic!`, не меняя публичный договор «Последовательные вычисления and_then». Добавить один общий вариант Other(String) и преобразовывать в него все ошибки до классификации.

Вопрос 7 из 20

Что показывает `String::from` применительно к механизму «Преобразование Option через map»?

let value = Some(String::from("rust"));
let len = value.as_ref().map(|s| s.len());
assert_eq!(len, Some(4));
assert_eq!(value.as_deref(), Some("rust"));

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

Вопрос 8 из 20

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

fn find_even(xs: &[i32]) -> Option<i32> {
    xs.iter().copied().find(|n| n % 2 == 0)
}
println!("{:?}", find_even(&[1, 3, 5]));

Сборка пройдёт, поскольку unwrap превращает любой Err или None в значение, используя Default. Код печатает None: отсутствие подходящего элемента выражено отдельным вариантом Result, а не специальным числом. Код компилируется, но none и Err различаются только форматом печати, но не управлением выполнением. Следовательно, для `find_even` не понадобилось бы явное предусловие. До запуска дело не дойдёт: map нельзя вызывать для None или Err. До последней строки и наблюдаемого результата программа при таком разборе не доходит. Код печатает None: отсутствие подходящего элемента выражено отдельным вариантом Option, а не специальным числом.

Вопрос 9 из 20

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

use std::mem::size_of;
assert_eq!(size_of::<Option<&u8>>(), size_of::<&u8>());

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

Вопрос 10 из 20

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

let configured: Option<u16> = None;
let port = configured.unwrap_or_else(|| 8080);
println!("{port}");

При ошибке `configured` возвращать значение по умолчанию, не сообщая вызывающему коду причину и возможность восстановления. Возвращать None вместо всех ошибок: вызывающему коду не нужно знать причину отказа. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Поэтому ошибочный сценарий вокруг `unwrap_or_else` не проверяли бы отдельно. Заменить обработку результата `configured` на `unwrap` или `expect`, сохранив прежний возвращаемый тип функции. Считать этот отказ нарушением внутреннего инварианта и использовать `panic!`, не меняя публичный договор «Безопасное извлечение». Выбрать match, unwrap_or, unwrap_or_else или? по смыслу контракта; unwrap использовать лишь когда инвариант действительно доказан и объяснён.

Вопрос 11 из 20

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

let value: Option<String> = None;
let len = value.map(|s| s.len());
println!("{len:?}");

Заменить обработку результата `Option` на `unwrap` или `expect`, сохранив прежний возвращаемый тип функции. Считать этот отказ нарушением внутреннего инварианта и использовать `panic!`, не меняя публичный договор «Преобразование Option через map». Использовать map для чистого преобразования T в U; если функция уже возвращает Option<U>, выбрать and_then, чтобы не получить вложенный Option. При ошибке `Option` возвращать значение по умолчанию, не сообщая вызывающему коду причину и возможность восстановления. Преобразовать каждую ошибку в String в самом нижнем слое и удалить исходный тип причины. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Проверку ошибки для `map` при таком подходе заменили бы успешным примером.

Вопрос 12 из 20

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

Map и and_then одинаково устраняют вложенный Option или Result. Поэтому ошибочный сценарий вокруг «Some и None» не проверяли бы отдельно. Unwrap превращает любой Err или None в значение, используя Default. Такое рассуждение переносило бы вывод о «Some и None» на неисполненную ветвь. Паника является обычным возвращаемым значением Result и перехватывается оператором вопросительного знака. Option<T> моделирует наличие Some(T) или отсутствие None и заставляет вызывающий код явно выбрать способ обработки. Option и Result отличаются только названиями вариантов и взаимозаменяемы без потери контракта.

Вопрос 13 из 20

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

fn parse_port(s: &str) -> Option<u16> { s.parse().ok() }
let result = Some("8080").and_then(parse_port);
println!("{result:?}");

Проверка типов пропустит этот путь: map и and_then одинаково устраняют вложенный Option или Result. Код печатает Some(8080): and_then принимает функцию, уже возвращающую Result, и не создаёт вложенности. Такая запись допустима, так как unwrap превращает любой Err или None в значение, используя Default. Поэтому ошибочный сценарий вокруг `parse_port` не проверяли бы отдельно. Код печатает Some(8080): and_then принимает функцию, уже возвращающую Option, и не создаёт вложенности. Компиляция завершится успешно: строковый текст ошибки сохраняет тип причины и автоматическую цепочку source.

Вопрос 14 из 20

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

let value = Some(String::from("ready"));
let text = value.as_deref().unwrap_or("fallback");
assert_eq!(text, "ready");

Успешного основного сценария достаточно; отмену, частичное завершение и повторный вход отдельно проверять не нужно. as_deref позволяет получить Option<&str> без клонирования, а unwrap_or задаёт заимствованный запасной текст. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Отсутствие сообщения инструмента означает, что опасная ветвь была выполнена и признана корректной. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Дополнительный сценарий вокруг `String::from` при таком толковании уже не требуется. Из этого следовало бы, что иной порядок операций для `as_deref` ничего не меняет.

Вопрос 15 из 20

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

Map и and_then одинаково устраняют вложенный Option или Result. Поэтому ошибочный сценарий вокруг «Безопасное извлечение» не проверяли бы отдельно. Unwrap превращает любой Err или None в значение, используя Default. Тогда различия между обычным и граничным случаем для «Безопасное извлечение» исчезли бы. Unwrap безопасен в библиотечном коде, если ошибочный вход кажется маловероятным. В результате «Безопасное извлечение» считали бы безопасным и на путях, которых пример не выполняет. Безопасное извлечение Option означает явное поведение для None; ленивые варианты не выполняют дорогой запасной расчёт при Some. Option и Result отличаются только названиями вариантов и взаимозаменяемы без потери контракта. Проверку ошибки для «Безопасное извлечение» при таком подходе заменили бы успешным примером.

Вопрос 16 из 20

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

let nested = Some("x").map(|s| s.parse::<u32>().ok());
let flat = Some("x").and_then(|s| s.parse::<u32>().ok());
assert_eq!(nested, Some(None));
assert_eq!(flat, None);

Отсутствие сообщения инструмента означает, что опасная ветвь была выполнена и признана корректной. Успешная ветвь служит достаточным доказательством поведения при ошибке и повторном выполнении. В результате `map` считали бы безопасным и на путях, которых пример не выполняет. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. В результате `map` считали бы безопасным и на путях, которых пример не выполняет. Сравнение показывает: map сохраняет вложенный Option, а and_then превращает неудачу второго шага в общий None. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Дополнительный сценарий вокруг `map` при таком толковании уже не требуется.

Вопрос 17 из 20

Что отделяет корректное применение «Преобразование Option через map» от случайно работающего решения?

Option и Result отличаются только названиями вариантов и взаимозаменяемы без потери контракта. Тогда различия между обычным и граничным случаем для «Преобразование Option через map» исчезли бы. Unwrap превращает любой Err или None в значение, используя Default. Option::map сохраняет структуру контейнера: Some(T) становится Some(U), а None остаётся None без вызова функции. Map всегда уплощает вложенный контейнер так же, как and_then. Такое рассуждение переносило бы вывод о «Преобразование Option через map» на неисполненную ветвь. Map и and_then одинаково устраняют вложенный Option или Result. Следовательно, для «Преобразование Option через map» не понадобилось бы явное предусловие.

Вопрос 18 из 20

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

fn find_even(xs: &[i32]) -> Option<i32> {
    xs.iter().copied().find(|n| n % 2 == 0)
}
println!("{:?}", find_even(&[1, 3, 5]));

Возвращать None вместо всех ошибок: вызывающему коду не нужно знать причину отказа. При ошибке `find_even` возвращать значение по умолчанию, не сообщая вызывающему коду причину и возможность восстановления. Считать этот отказ нарушением внутреннего инварианта и использовать `panic!`, не меняя публичный договор «Some и None». Вернуть Option и обработать обе ветви; не подменять отсутствие значением 0, если ноль является допустимым результатом. Заменить обработку результата `find_even` на `unwrap` или `expect`, сохранив прежний возвращаемый тип функции.

Вопрос 19 из 20

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

Строковый текст ошибки сохраняет тип причины и автоматическую цепочку source. Map и and_then одинаково устраняют вложенный Option или Result. По этой логике отдельная проверка «Последовательные вычисления and_then» на другом входе считалась бы лишней. Map всегда уплощает вложенный контейнер так же, как and_then. and_then выполняет функцию только для Some и выравнивает результат Option<Option<U>> до Option<U>. Option и Result отличаются только названиями вариантов и взаимозаменяемы без потери контракта. Следовательно, для «Последовательные вычисления and_then» не понадобилось бы явное предусловие.

Вопрос 20 из 20

Какой край контракта «Последовательные вычисления and_then» чаще всего остаётся незамеченным?

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