Вы забудете о необработанных исключениях, если научитесь обращаться с ошибками, как это принято в Rust
Обработка ошибок – важнейшая часть любого языка программирования, а в Rust предлагается для этого уникальный мощный подход. Rust, в отличие от многих других языков программирования, не предлагает исключений, а предоставляет перечисление Result. У разработчика нет иного выхода, кроме как обрабатывать все ошибки согласованно и предсказуемо. Поэтому ошибки становится проще идентифицировать и диагностировать.
Поскольку в Rust не предусмотрены исключения, любая функция обязана возвращать либо значение, либо "панику". Когда функция паникует, процесс сразу же завершается и предоставляет вызывающей стороне конкретную обратную связь. Чисто технически можно отлавливать случаи паники в Rust при помощи catch_unwind, но постоянно так делать не рекомендуется. Вместо этого в Rust предлагается перечисление Result; пользуясь им, разработчик вынужден обрабатывать все ошибки сам.
В этом посте будут рассмотрены применяемые в Rust идиоматические паттерны обработки ошибок, и вы в общих чертах поймёте, как это делается. Мы разберём перечисление Result, посмотрим, как с его помощью обрабатываются ошибки в программах Rust, и какие крейты чаще всего используются, чтобы упростить этот процесс.
Тип Result
Если функция подвержена ошибкам — то есть, она может тем или образом отказать — то обычно она возвращает тип Result, предусмотренный в Rust. При возврате Result от функции разработчик обязан возвращать её в одном из существующих вариантов: Result::Ok и Result::Err. Так как эти варианты так распространены, они предоставляются в prelude, поэтому можно написать просто Ok или Err.
Поскольку Result – это перечисление, не составляет труда сопоставить его с ошибкой и обработать любой из случаев:
fn fallible(succeed: bool) -> Result<&'static str, &'static str> {
if succeed {
return Ok("success!");
}
Err("this is an error message")
}
fn main() -> Result<(), &'static str> {
let result = fallible(false);
let value = match result {
Ok(value) => value,
Err(err) => {
return Err(err);
}
};
println!("got a value: {value}");
Ok(())
}Как видите, здесь можно воспользоваться стандартным оператором match, предусмотренным в Rust. Этот оператор предусмотрен для ветвления в любой из вариантов перечисления. В Rust функция не выбрасывает исключения, а либо выполняет panic (в идеале, такого не должно происходить ни в коем случае), либо возвращает тип Result. В этом искусственном примере код всегда возвращает ошибку, но можно представить себе и более сложную функцию, которая отказывала бы каким-нибудь неожиданным образом.
Rust разрешает возвращать Result даже в функции main. Если значение, возвращённое из функции main, является ошибкой, то Rust выведет эту ошибку в отладочном представлении Debug и завершит процесс, сопроводив его кодом ошибки.
Оператор «вопросительный знак»
Когда в базе кода активно используется Result, обрабатывать каждый отдельный случай ошибки может быть затруднительно. Чтобы упростить эту ситуацию, в Rust предлагается оператор «вопросительный знак», при помощи которого мы сокращённо представляем развёртку успешного результата или возвращаем ошибку вызывающей стороне. В сущности, этот оператор «вопросительный знак» доставляет ошибку вызывающей стороне, обеспечивая «всплытие» этой ошибки.
Например, вот как можно значительно упростить предыдущий пример:
fn fallible(succeed: bool) -> Result<&'static str, &'static str> {
if succeed {
return Ok("success!");
}
Err("this is an error message")
}
fn main() -> Result<(), &'static str> {
let value = fallible(false)?;
println!("got a value: {value}");
Ok(())
}Этот пример полностью эквивалентен первому, но здесь при помощи оператора? мы с лёгкостью извлекаем интересующее нас значение из Result::Ok, если оно там есть. В противном случае возвращаем вызывающей стороне вариант Result::Error.
Ошибки при упаковке
В вышеприведённых примерах мы разбирали возвращаемые ошибки, представляющие собой простые строки. В более сложном сценарии выше вероятность, что вы столкнётесь с иными типами ошибок – программа также может их возвращать.
Рассмотрим следующий пример:
use reqwest::blocking::get;
fn download() -> Result<String, reqwest::Error> {
let website_text = get("https://www.rust-lang.org")?.text()?;
Ok(website_text)
}
fn main() -> Result<(), reqwest::Error> {
let value = download()?;
println!("got a value: {value}");
Ok(())
}В этом примере мы скачиваем информацию с сайта https://www.rust-lang.org и используем оператор ?, чтобы упростить обработку ошибок. Обратите внимание: второй тип, передаваемый каждому из Result – это теперь reqwest::Error. Этот тип нам подходит, поскольку и get(), и text() возвращают Result с ошибкой типа reqwest::Error.
Теперь допустим, что вы также хотите сохранить текст со скачанного сайта в отдельном файле. Легко дополнить наш код, чтобы в нём выполнялась и такая операция:
use tempfile::tempfile;
use std::io::copy;
use reqwest::blocking::get;
fn download() -> Result<String, reqwest::Error> {
let mut file = tempfile()?;
let website_text = get("https://www.rust-lang.org")?.text()?;
copy(&mut website_text.as_bytes(), &mut file)?;
Ok(website_text)
}
fn main() -> Result<(), reqwest::Error> {
let value = download()?;
println!("got a value: {value}");
Ok(())
}Но этот код не компилируется! При попытке его собрать получаем следующую ошибку:
|
5 | fn download() -> Result<String, reqwest::Error> {
| ------------------------------ expected `reqwest::Error` because of this
6 | let mut file = tempfile()?;
| ^ the trait `From<std::io::Error>` is not implemented for `reqwest::Error`
|
= note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
= help: the following other types implement trait `FromResidual<R>`:
<Result<T, F> as FromResidual<Result<Infallible, E>>>
<Result<T, F> as FromResidual<Yeet<E>>>
= note: required for `Result<String, reqwest::Error>` to implement `FromResidual<Result<Infallible, std::io::Error>>`Такая ошибка возникает, так как tempfile() возвращает тип ошибки, не совпадающий с сигнатурой нашей функции Result<String, reqwest::Error>. Проще всего решить эту проблему так: «упаковать» ошибку, а затем вернуть вместо неё Result<String, Box<dyn std::error::Error>>.
В стандартной библиотеке предоставляется такой типаж std::error::Error, предназначенный для обработки как раз тех случаев, в которых нам требуется возвращать по несколько типов ошибок. Ошибки тех типов, что предоставляются в библиотеках, должны реализовывать Error, чтобы мы могли без труда преобразовывать различные типы ошибок в обобщённый типаж object. Опять же, оператор «вопросительный знак» это сильно упрощает до степени «просто работает».
use reqwest::blocking::get;
use std::error::Error;
use std::io::copy;
use tempfile::tempfile;
fn download() -> Result<String, Box<dyn Error>> {
let mut file = tempfile()?;
let website_text = get("https://www.rust-lang.org")?.text()?;
copy(&mut website_text.as_bytes(), &mut file)?;
Ok(website_text)
}
fn main() -> Result<(), Box<dyn Error>> {
let value = download()?;
println!("got a value: {value}");
Ok(())
}Также стоит отметить anyhow, ещё один популярный крейт, который схожим образом позволяет использовать типаж Box>, но с некоторыми дополнениями, которые повышают эргономичность работы.
Использование thiserror
Есть такой недостаток при использовании anyhow или Box>: мы теряем информацию о типах ошибок, возвращаемых функции, а знать типы зачастую полезно, когда программируешь логику ветвления в зависимости от того, какая именно ошибка возникла.
При отслеживании контекста ошибки действует такое соглашение: собираем наше собственное перечисление ошибок, в котором описываются все типы ошибок, что могут произойти в данном крейте или модуле.
use reqwest::blocking::get;
use std::io::copy;
use tempfile::tempfile;
fn download() -> Result<String, Error> {
let mut file = tempfile().map_err(|_| Error::File)?;
let website_text = get("https://www.rust-lang.org")
.map_err(|_| Error::Download)?
.text()
.map_err(|_| Error::Download)?;
copy(&mut website_text.as_bytes(), &mut file).map_err(|_| Error::File)?;
Ok(website_text)
}
fn main() -> Result<(), Error> {
let value = download()?;
println!("got a value: {value}");
Ok(())
}
#[derive(Debug)]
enum Error {
File,
Download,
}Теперь вызывающая сторона знает контекст и тип той ошибки, которая возникла в функции скачивания. Но нам требуется вручную преобразовать ошибки, чтобы поместить их в наше пользовательское перечисление Error. Для этого применяется функция map_err, довольно неудобная и многословная.
При помощи Thiserror проще отображать типы ошибок на созданные вами пользовательские типы ошибок:
use reqwest::blocking::get;
use std::io::copy;
use tempfile::tempfile;
use thiserror::Error;
fn download() -> Result<String, Error> {
let mut file = tempfile()?;
let website_text = get("https://www.rust-lang.org")?.text()?;
copy(&mut website_text.as_bytes(), &mut file)?;
Ok(website_text)
}
fn main() -> Result<(), Error> {
let value = download()?;
println!("got a value: {value}");
Ok(())
}
#[derive(Debug, Error)]
enum Error {
#[error("file error: {0}")]
File(#[from] std::io::Error),
#[error("download error: {0}")]
Download(#[from] reqwest::Error),
}Обратите внимание, как нам удалось сохранить отображение ошибок на наше собственное декларативное перечисление. Для этого мы воспользовались макросами, которые предоставляются в thiserror. Наш код остаётся чистым, а для контролируемого просачивания ошибок в нём мы можем с лёгкостью воспользоваться оператором «вопросительный знак».
Заключение
Обработка ошибок – неотъемлемая составляющая любого языка программирования, а в Rust она реализована особенно хорошо и надёжно. Rust, в отличие от многих других языков программирования, вообще не использует исключений, а перечисляет вместо них перечисление Result, при работе с которым программисту приходится самостоятельно обрабатывать все ошибки. Программировать в таком стиле не только эффективнее, но и приятнее. Благодаря перечислению Result очень просто осмысливать возникающие условия ошибок и справляться с ними в коде.
____
P.S.
Также обращаем ваше внимание на то, что у нас на сайте проходит распродажа.
