Result и обработка ошибок — бесплатный тест онлайн

Вопрос 1 из 20

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

Option и Result отличаются только названиями вариантов и взаимозаменяемы без потери контракта. Следовательно, поведение `std::num::ParseIntError` считалось бы одинаковым для всех допустимых типов. Оператор? подавляет ошибку и продолжает функцию со значением Default. Следовательно, поведение `std::num::ParseIntError` считалось бы одинаковым для всех допустимых типов. Map и and_then одинаково устраняют вложенный Option или Result. Тогда различия между обычным и граничным случаем для «Оператор распространения ошибки?» исчезли бы. Оператор вопросительного знака перехватывает ошибку и продолжает функцию со значением по умолчанию. Контракт «Оператор распространения ошибки?» считался бы одинаковым при любом состоянии входа. Оператор? разворачивает успешное значение и при остаточном результате выполняет ранний возврат, используя механизм FromResidual и преобразование ошибки при необходимости.

Вопрос 2 из 20

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

fn first(xs: &[i32]) -> Option<i32> { Some(*xs.first()?) }
assert_eq!(first(&[]), None);

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

Вопрос 3 из 20

Как поведёт себя программа при достижении `divide`?

fn divide(a: i32, b: i32) -> Result<i32, &'static str> {
    if b == 0 { Err("division by zero") } else { Ok(a / b) }
}
println!("{:?}", divide(8, 0));

Выполнение продолжается без паники, поскольку оператор вопросительного знака перехватывает ошибку и продолжает функцию со значением по умолчанию. Компилятор отклоняет код до запуска, потому что result нельзя возвращать из обычной функции без async. Выполнение продолжается без паники, поскольку строковый текст ошибки сохраняет тип причины и автоматическую цепочку source. Код печатает Err("division by zero"): ожидаемый отказ представлен значением Result, а не паникой. Компилятор отклоняет код до запуска, потому что пользовательский тип ошибки обязан хранить строку и не может быть enum.

Вопрос 4 из 20

Какой узкий вывод следует из проверки `LoadError::Invalid`?

let err = load("bad").unwrap_err();
assert!(matches!(err, LoadError::Invalid(_)));

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

Вопрос 5 из 20

Какой вариант правки возвращает фрагмент с `std::num::ParseIntError` к корректному контракту?

use std::num::ParseIntError;
fn twice(s: &str) -> Result<i32, ParseIntError> {
    let n: i32 = s.parse()?;
    Ok(n * 2)
}
println!("{:?}", twice("x"));

Считать полный текст Display стабильным машинным кодом ошибки для ветвления и тестов. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Контракт `twice` считался бы одинаковым при любом состоянии входа. При ошибке `std::num::ParseIntError` возвращать значение по умолчанию, не сообщая вызывающему коду причину и возможность восстановления. Заменить обработку результата `std::num::ParseIntError` на `unwrap` или `expect`, сохранив прежний возвращаемый тип функции. Считать этот отказ нарушением внутреннего инварианта и использовать `panic!`, не меняя публичный договор «Оператор распространения ошибки?». Использовать `?`, когда тип ошибки совместим с результатом функции; контекст при необходимости добавить через `map_err` или подходящий адаптер.

Вопрос 6 из 20

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

#[derive(Debug)]
enum LoadError { Empty, Invalid(std::num::ParseIntError) }
fn load(s: &str) -> Result<i32, LoadError> {
    if s.is_empty() { return Err(LoadError::Empty); }
    s.parse().map_err(LoadError::Invalid)
}

При ошибке `derive` возвращать значение по умолчанию, не сообщая вызывающему коду причину и возможность восстановления. Контракт `load` считался бы одинаковым при любом состоянии входа. Считать этот отказ нарушением внутреннего инварианта и использовать `panic!`, не меняя публичный договор «Собственные ошибки». Возвращать None вместо всех ошибок: вызывающему коду не нужно знать причину отказа. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Такое рассуждение переносило бы вывод о `load` на неисполненную ветвь. Создать enum по категориям отказа и хранить исходную ошибку в соответствующем варианте; не превращать все причины в одинаковую строку слишком рано. Преобразовать любую ошибку вокруг данные этого фрагмента в строку в самом нижнем слое и ветвиться по тексту сообщения.

Вопрос 7 из 20

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

Result<T, E> разделяет успешное значение Ok(T) и ожидаемую ошибку Err(E), сохраняя тип причины. Паника является обычным возвращаемым значением Result и перехватывается оператором вопросительного знака. Поэтому ошибочный сценарий вокруг «Ok и Err» не проверяли бы отдельно. Оператор вопросительного знака перехватывает ошибку и продолжает функцию со значением по умолчанию. Оператор? подавляет ошибку и продолжает функцию со значением Default. Строковый текст ошибки сохраняет тип причины и автоматическую цепочку source. Из этого следовало бы, что иной порядок операций для «Ok и Err» ничего не меняет.

Вопрос 8 из 20

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

#[derive(Debug)]
struct ConfigError { path: String, source: std::io::Error }
// В тесте проверяют path и kind(), а не полный текст Display.

Структурные поля path и source.kind() дают устойчивую проверку контекста и причины без зависимости от локализованного сообщения ОС. Совпадение полного текста диагностики является главным и стабильным контрактом этой проверки. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Дополнительный сценарий вокруг `std::io::Error` при таком толковании уже не требуется. Отсутствие сообщения инструмента означает, что опасная ветвь была выполнена и признана корректной. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно.

Вопрос 9 из 20

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

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

Вопрос 10 из 20

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

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

Вопрос 11 из 20

Какой результат даст этот фрагмент с `std::num::ParseIntError`?

use std::num::ParseIntError;
fn twice(s: &str) -> Result<i32, ParseIntError> {
    let n: i32 = s.parse()?;
    Ok(n * 2)
}
println!("{:?}", twice("x"));

Код возвращает Err(ParseIntError): оператор? прекращает функцию при ошибке и передаёт её наружу. Проверка типов завершится ошибкой: option требует отдельного null-указателя в памяти для каждого значения. В результате `twice` считали бы безопасным и на путях, которых пример не выполняет. Код не пройдёт проверку: контекст ошибки запрещает использовать оператор source. До запуска дело не дойдёт: result нельзя возвращать из обычной функции без async. Rust примет этот код, поскольку оператор вопросительного знака перехватывает ошибку и продолжает функцию со значением по умолчанию.

Вопрос 12 из 20

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

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

Вопрос 13 из 20

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

#[derive(Debug)]
enum LoadError { Empty, Invalid(std::num::ParseIntError) }
fn load(s: &str) -> Result<i32, LoadError> {
    if s.is_empty() { return Err(LoadError::Empty); }
    s.parse().map_err(LoadError::Invalid)
}

Проверка типов завершится ошибкой: контекст ошибки запрещает использовать оператор source. Код различает пустой ввод и ошибку разбора, сохраняя исходный ParseIntError внутри варианта Invalid. До выполнения код дойдёт без ошибки компиляции, поскольку строковый текст ошибки сохраняет тип причины и автоматическую цепочку source. Фрагмент не соберётся: пользовательский тип ошибки обязан хранить строку и не может быть enum. Код компилируется и даёт ожидаемый результат: контекст можно добавлять без сохранения исходной ошибки, а текст полностью заменяет тип. Проверку ошибки для `load` при таком подходе заменили бы успешным примером.

Вопрос 14 из 20

Как исправить участок с `divide` без обхода проверки компилятора?

fn divide(a: i32, b: i32) -> Result<i32, &'static str> {
    if b == 0 { Err("division by zero") } else { Ok(a / b) }
}
println!("{:?}", divide(8, 0));

При ошибке `divide` возвращать значение по умолчанию, не сообщая вызывающему коду причину и возможность восстановления. Возвращать Err для ожидаемой ошибки входа и обрабатывать её вызывающим кодом; panic оставлять для нарушенного внутреннего инварианта или невозможного продолжения. Заменить обработку результата `divide` на `unwrap` или `expect`, сохранив прежний возвращаемый тип функции. Нарушение условия превращается в панику вместо явного результата, который мог бы обработать вызывающий код. Логировать ошибку и затем возвращать Ok со значением по умолчанию, не меняя контракт функции. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Считать этот отказ нарушением внутреннего инварианта и использовать `panic!`, не меняя публичный договор «Ok и Err».

Вопрос 15 из 20

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

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

Вопрос 16 из 20

На какое правило следует опираться при ревью кода по теме «Собственные ошибки»?

Контекст можно добавлять без сохранения исходной ошибки, потому что текст полностью заменяет тип. Из этого следовало бы, что иной порядок операций для «Собственные ошибки» ничего не меняет. Повтор операции безопасен для любой ошибки, если сделать достаточно попыток. Такое рассуждение переносило бы вывод о «Собственные ошибки» на неисполненную ветвь. Строковый текст ошибки сохраняет тип причины и автоматическую цепочку source. В результате «Собственные ошибки» считали бы безопасным и на путях, которых пример не выполняет. Все ошибки ввода-вывода можно повторять, потому что они по определению временные. Следовательно, поведение `std::num::ParseIntError` считалось бы одинаковым для всех допустимых типов. Собственный enum ошибок делает варианты частью API и позволяет вызывающему коду восстанавливаться по категории, сохраняя источник.

Вопрос 17 из 20

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

let result: Result<i32, &str> = Err("bad");
assert!(result.is_err());
assert_eq!(result.err(), Some("bad"));

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

Вопрос 18 из 20

Какое изменение решает проблему в месте применения `io::Error`?

use std::{fs, io};
fn read_config(path: &str) -> Result<String, io::Error> {
    fs::read_to_string(path)
}

Преобразовать каждую ошибку в String в самом нижнем слое и удалить исходный тип причины. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. При ошибке `read_config` возвращать значение по умолчанию, не сообщая вызывающему коду причину и возможность восстановления. Заменить обработку результата `read_config` на `unwrap` или `expect`, сохранив прежний возвращаемый тип функции. Добавить контекст уровня операции, сохранив source: например, собственный вариант с path и io::Error либо контекстный тип приложения. Возвращать None вместо всех ошибок: вызывающему коду не нужно знать причину отказа. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. По этой логике отдельная проверка `read_config` на другом входе считалась бы лишней.

Вопрос 19 из 20

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

Source строится автоматически из текста Display без явной связи между ошибками. По этой логике отдельная проверка «Контекст причины» на другом входе считалась бы лишней. Строковый текст ошибки сохраняет тип причины и автоматическую цепочку source. Из этого следовало бы, что иной порядок операций для «Контекст причины» ничего не меняет. Контекст можно добавлять без сохранения исходной ошибки, потому что текст полностью заменяет тип. Тогда поведение «Контекст причины» при раннем выходе выводили бы из обычного пути. Хорошая цепочка ошибок добавляет смысл текущего слоя и сохраняет исходную причину для диагностики, а не заменяет её безвозвратной строкой. Типизированная ошибка мешает добавлять контекст, поэтому приложение должно хранить только String. Тогда поведение «Контекст причины» при раннем выходе выводили бы из обычного пути.

Вопрос 20 из 20

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

use std::{fs, io};
fn read_config(path: &str) -> Result<String, io::Error> {
    fs::read_to_string(path)
}

Ошибка возникнет на этапе компиляции: контекст ошибки запрещает использовать оператор source. До последней строки и наблюдаемого результата программа при таком разборе не доходит. Код компилируется, но цепочка причин собирается только из текста Display и не зависит от типов. Значит, выполнение должно пройти через `io::Error` без изменения сигнатуры. Проверка типов пропустит этот путь: строковый текст ошибки сохраняет тип причины и автоматическую цепочку source. Код компилируется и даёт ожидаемый результат: контекст можно добавлять без сохранения исходной ошибки, а текст полностью заменяет тип. Тогда поведение `read_config` при раннем выходе выводили бы из обычного пути. Функция сохраняет исходный io::Error, но без дополнительного контекста вызывающему коду может быть неясно, какой именно файл или этап отказал.