Rust на примерах

   • Err(why), который показывает, что операция потерпела неудачу, оборачивает значение ошибки (причину, why), которое (надеемся) описывает причину неудачи. why имеет тип E.

mod checked {

// Математические "ошибки", которые мы хотим отлавливать

#[derive(Debug)]

pub enum MathError {

DivisionByZero,

NonPositiveLogarithm,

NegativeSquareRoot,

}

pub type MathResult = Result;

pub fn div(x: f64, y: f64) -> MathResult {

if y == 0.0 {

// При таком значение операция потерпит неудачу.

// Вместо этого давайте вернём ошибку, обёрнутую в `Err`

Err(MathError::DivisionByZero)

} else {

// Эта операция возможна, так что вернём результат, обёрнутый в `Ok`

Ok(x / y)

}

}

pub fn sqrt(x: f64) -> MathResult {

if x < 0.0 {

Err(MathError::NegativeSquareRoot)

} else {

Ok(x.sqrt())

}

}

pub fn ln(x: f64) -> MathResult {

if x <= 0.0 {

Err(MathError::NonPositiveLogarithm)

} else {

Ok(x.ln())

}

}

}

// `op(x, y)` === `sqrt(ln(x / y))`

fn op(x: f64, y: f64) -> f64 {

// Это трёхуровневая пирамида из `match`!

match checked::div(x, y) {

Err(why) => panic!("{:?}", why),

Ok(ratio) => match checked::ln(ratio) {

Err(why) => panic!("{:?}", why),

Ok(ln) => match checked::sqrt(ln) {

Err(why) => panic!("{:?}", why),

Ok(sqrt) => sqrt,

},

},

}

}

fn main() {

// Потерпит ли это неудачу?

println!("{}", op(1.0, 10.0));

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

?

Разбор цепочки результатов с использованием match может стать довольно неопрятной, к счастью, с помощью оператора ? можно сделать разбор снова красивым. ? используется в конце выражения, возвращающего Result и эквивалентен выражению match, в котором ветка Err(err) разворачивается в Err(From::from(err)), а ветка Ok(ok) во внутреннее значение (ok).

mod checked {

#[derive(Debug)]

enum MathError {

DivisionByZero,

NonPositiveLogarithm,

NegativeSquareRoot,

}

type MathResult = Result;

fn div(x: f64, y: f64) -> MathResult {

if y == 0.0 {

Err(MathError::DivisionByZero)

} else {

Ok(x / y)

}

}

fn sqrt(x: f64) -> MathResult {

if x < 0.0 {

Err(MathError::NegativeSquareRoot)

} else {

Ok(x.sqrt())

}

}

fn ln(x: f64) -> MathResult {

if x <= 0.0 {

Err(MathError::NonPositiveLogarithm)

} else {

Ok(x.ln())

}

}

// Промежуточная функция

fn op_(x: f64, y: f64) -> MathResult {

// Если `div` "упадёт", тогда будет "возвращено" `DivisionByZero`

let ratio = div(x, y)?;

// если `ln` "упадёт", тогда будет "возвращено" `NonPositiveLogarithm`