Rust by Example

Option

Sometimes it's desirable to catch the failure of some parts of a program instead of calling panic!; this can be accomplished using the Option enum.

The Option enum has two variants:

• None, to indicate failure or lack of value, and

• Some(value), a tuple struct that wraps a value with type T.

// An integer division that doesn't `panic!`

fn checked_division(dividend: i32, divisor: i32) -> Option {

if divisor == 0 {

// Failure is represented as the `None` variant

None

} else {

// Result is wrapped in a `Some` variant

Some(dividend / divisor)

}

}

// This function handles a division that may not succeed

fn try_division(dividend: i32, divisor: i32) {

// `Option` values can be pattern matched, just like other enums

match checked_division(dividend, divisor) {

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