Rust by Example

None => println!("{} / {} failed!", dividend, divisor),

Some(quotient) => {

println!("{} / {} = {}", dividend, divisor, quotient)

},

}

}

fn main() {

try_division(4, 2);

try_division(1, 0);

// Binding `None` to a variable needs to be type annotated

let none: Option = None;

let _equivalent_none = None::;

let optional_float = Some(0f32);

// Unwrapping a `Some` variant will extract the value wrapped.

println!("{:?} unwraps to {:?}", optional_float, optional_float.unwrap());

// Unwrapping a `None` variant will `panic!`

println!("{:?} unwraps to {:?}", none, none.unwrap());

}

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

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Result

We've seen that the Option enum can be used as a return value from functions that may fail, where None can be returned to indicate failure. However, sometimes it is important to express why an operation failed. To do this we have the Result enum.

The Result enum has two variants:

   • Ok(value) which indicates that the operation succeeded, and wraps the value returned by the operation. (value has type T)

   • Err(why), which indicates that the operation failed, and wraps why, which (hopefully) explains the cause of the failure. (why has type E)

mod checked {

// Mathematical "errors" we want to catch

#[derive(Debug)]

pub enum MathError {

DivisionByZero,

NonPositiveLogarithm,

NegativeSquareRoot,

}

pub type MathResult = Result;

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

if y == 0.0 {

// This operation would `fail`, instead let's return the reason of

// the failure wrapped in `Err`

Err(MathError::DivisionByZero)

} else {

// This operation is valid, return the result wrapped in `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 {

// This is a three level match pyramid!

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() {

// Will this fail?

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

}