Rust на примерах — страница 49 из 65

// Теперь мы сможем написать наши собственные ошибки, реализовать приведение до основной ошибки
// или сделать что-то ещё между приведениями.
#[derive(Debug, Clone)]
struct DoubleError;
// Генерация ошибки полностью отделена от того, как она отображается.
// Нет необходимости в загромождении сложной логикой построения отображения ошибки.
//
// Мы не храним дополнительной информации об ошибках. Это означает, что мы не можем вывести строку, которую не удалось обработать, без изменения наших типов.
impl fmt::Display for DoubleError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "неверный первый элемент")
}
}
fn double_first(vec: Vec<&str>) -> Result {
vec.first()
// Изменим ошибку на наш новый тип.
.ok_or(DoubleError)
.and_then(|s| {
s.parse::()
// Обновим тип ошибки также здесь.
.map_err(|_| DoubleError)
.map(|i| 2 * i)
})
}
fn print(result: Result) {
match result {
Ok(n) => println!("Первое удвоение {}", n),
Err(e) => println!("Ошибка: {}", e),
}
}
fn main() {
let numbers = vec!["42", "93", "18"];
let empty = vec![];
let strings = vec!["tofu", "93", "18"];
print(double_first(numbers));
print(double_first(empty));
print(double_first(strings));
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Упаковка ошибок (Box)

Чтобы написать простой код и при этом использовать оригинальные ошибки, необходимо упаковать (Box) их. Минусом данного способа является то, что тип ошибок известен только во время выполнения программы, а не определён статически.

Стандартная библиотека помогает упаковывать наши ошибки. Это достигается за счёт того, что для Box реализована конвертация из любого типа, реализующего типаж Error, в типаж-объект Box через From.

use std::error;
use std::fmt;
// Создадим псевдоним с типом ошибки `Box`.
type Result = std::result::Result>;
#[derive(Debug, Clone)]
struct EmptyVec;
impl fmt::Display for EmptyVec {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "неверный первый элемент")
}
}
impl error::Error for EmptyVec {}
fn double_first(vec: Vec<&str>) -> Result {
vec.first()
.ok_or_else(|| EmptyVec.into()) // Упаковка (преобразование в Box)
.and_then(|s| {
s.parse::()
.map_err(|e| e.into()) // Упаковка (преобразование в Box)
.map(|i| 2 * i)
})
}
fn print(result: Result) {
match result {
Ok(n) => println!("Удвоенный первый элемент: {}", n),
Err(e) => println!("Ошибка: {}", e),
}
}
fn main() {
let numbers = vec!["42", "93", "18"];
let empty = vec![];
let strings = vec!["tofu", "93", "18"];
print(double_first(numbers));
print(double_first(empty));
print(double_first(strings));
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Смотрите также:

Динамическая диспетчеризация и типажError

Другие способы использования?

Вы обратили внимание, что сразу же после вызова parse, мы в map_err упаковали ошибку из библиотеки?

.and_then(|s| s.parse::()
.map_err(|e| e.into())

Это простая и распространённая операция и было бы не плохо, если бы мы могли её опустить. Но из-за того, что and_then недостаточно гибок, мы не можем этого сделать. Однако, тут нам может помочь ?.

Ранее ? был рассмотрен как unwrap или return Err(err). По большей части это правда: на самом деле ? означает unwrap или return Err(From::from(err)). Поскольку From::from используется для преобразования между разными типами, применение ? к ошибке автоматически преобразует её в возвращаемый тип (при условии, что исходная ошибка может быть в него преобразована).

Теперь мы перепишем наш предыдущий пример с использованием ?. В результате у нас пропал map_err, так как для нашего типа реализован From::from:

use std::error;
use std::fmt;
// Создадим псевдоним с типом ошибки `Box`.
type Result = std::result::Result>;
#[derive(Debug)]
struct EmptyVec;
impl fmt::Display for EmptyVec {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "неверный первый элемент")
}
}
impl error::Error for EmptyVec {}
// Такая же последовательность, как и раньше, но вместо объединения
// всех `Result` и `Option`, мы используем `?` чтобы незамедлительно
// получить внутреннее значение.
fn double_first(vec: Vec<&str>) -> Result {
let first = vec.first().ok_or(EmptyVec)?;
let parsed = first.parse::()?;
Ok(2 * parsed)
}
fn print(result: Result) {
match result {
Ok(n)  => println!("Удвоенный первый элемент: {}", n),
Err(e) => println!("Ошибка: {}", e),
}
}
fn main() {