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

// Для компиляции и запуска с помощью Cargo этого примера без ошибок
// поменяйте в `Cargo.toml` значение поля `edition` секции
// `[package]` на "2015".
use std::num::ParseIntError;
fn multiply(first_number_str: &str, second_number_str: &str) -> Result {
let first_number = try!(first_number_str.parse::());
let second_number = try!(second_number_str.parse::());
Ok(first_number * second_number)
}
fn print(result: Result) {
match result {
Ok(n)  => println!("n равно {}", n),
Err(e) => println!("Ошибка: {}", e),
}
}
fn main() {
print(multiply("10", "2"));
print(multiply("t", "2"));
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1

Посмотрите главу "Другие способы использования ?" для большей информации.

Несколько типов ошибок

Предыдущие примеры всегда были очень удобны: Result взаимодействовали с другими Result, а Option - с другими Option.

Иногда Option необходимо взаимодействовать с Result, или Result с Result. В этих случаях, нам нужно управлять этими разными типами ошибок таким образом, чтобы можно было их компоновать и легко взаимодействовать с ними.

В следующем коде, два варианта unwrap генерируют разные типы ошибок. Vec::first возвращает Option, в то время как parse:: возвращает Result:

fn double_first(vec: Vec<&str>) -> i32 {
let first = vec.first().unwrap(); // Генерирует ошибку 1
2 * first.parse::().unwrap() // Генерирует ошибку 2
}
fn main() {
let numbers = vec!["42", "93", "18"];
let empty = vec![];
let strings = vec!["tofu", "93", "18"];
println!("Первое удвоенное {}", double_first(numbers));
println!("Первое удвоенное {}", double_first(empty));
// Ошибка 1: входной вектор пустой
println!("Первое удвоенное {}", double_first(strings));
// Ошибка 2: элемент не может быть преобразован в число
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

В следующих главах мы рассмотрим различные стратегии обработки этих типов проблем.

ИзвлечениеResultизOption

Наиболее простой способ обработки ошибок разных типов - это встраивание их друг в друга.

use std::num::ParseIntError;
fn double_first(vec: Vec<&str>) -> Option> {
vec.first().map(|first| {
first.parse::().map(|n| 2 * n)
})
}
fn main() {
let numbers = vec!["42", "93", "18"];
let empty = vec![];
let strings = vec!["tofu", "93", "18"];
println!("Первое удвоенное: {:?}", double_first(numbers));
println!("Первое удвоенное: {:?}", double_first(empty));
// Ошибка первая: исходный вектор пустой
println!("Первое удвоенное {:?}", double_first(strings));
// Ошибка вторая: элемент не переводится в число
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Бывает, мы хотим приостановить работу при ошибке (как при помощи оператора ?), но продолжать работать, если Option None. Есть пара комбинаторов, которые поменяют местами Result и Option.

use std::num::ParseIntError;
fn double_first(vec: Vec<&str>) -> Result, ParseIntError> {
let opt = vec.first().map(|first| {
first.parse::().map(|n| 2 * n)
});
opt.map_or(Ok(None), |r| r.map(Some))
}
fn main() {
let numbers = vec!["42", "93", "18"];
let empty = vec![];
let strings = vec!["tofu", "93", "18"];
println!("The first doubled is {:?}", double_first(numbers));
println!("The first doubled is {:?}", double_first(empty));
println!("The first doubled is {:?}", double_first(strings));
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Объявление типа ошибки

Иногда для упрощения кода необходимо скрыть все типы ошибок за какой-то одной ошибкой. Мы скроем их за пользовательской ошибкой.

Rust позволяет нам определить наш собственный тип ошибок. В общем случае "хороший" тип ошибки должен:

   • Представлять разные ошибки с таким же типом

   • Предоставлять хорошее сообщение об ошибке пользователю

   • Легко сравниваться с другими типами

      • Хорошо: Err(EmptyVec)

      • Плохо: Err("Пожалуйста, используйте вектор хотя бы с одним элементом".to_owned())

   • Содержать информацию об ошибке

      • Хорошо: Err(BadChar(c, position))

      • Плохо: Err("+ не может быть использован в данном месте".to_owned())

   • Хорошо сочетаться с другими ошибками

use std::error;
use std::fmt;
type Result = std::result::Result;
// Определите типы ошибок. Они могут быть настроены для наших случаев обработки ошибок.