Rust by Example

impl error::Error for EmptyVec {}

// The same structure as before but rather than chain all `Results`

// and `Options` along, we `?` to get the inner value out immediately.

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!("The first doubled is {}", n),

Err(e) => println!("Error: {}", 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

This is actually fairly clean now. Compared with the original panic, it is very similar to replacing the unwrap calls with ? except that the return types are Result. As a result, they must be destructured at the top level.

See also:

From::from and ?

Wrapping errors

An alternative to boxing errors is to wrap them in your own error type.

use std::error;

use std::error::Error as _;

use std::num::ParseIntError;

use std::fmt;

type Result = std::result::Result;

#[derive(Debug)]

enum DoubleError {

EmptyVec,

// We will defer to the parse error implementation for their error.

// Supplying extra info requires adding more data to the type.

Parse(ParseIntError),

}

impl fmt::Display for DoubleError {

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

match *self {

DoubleError::EmptyVec =>

write!(f, "please use a vector with at least one element"),

// The wrapped error contains additional information and is available

// via the source() method.

DoubleError::Parse(..) =>

write!(f, "the provided string could not be parsed as int"),

}

}

}

impl error::Error for DoubleError {

fn source(&self) -> Option<&(dyn error::Error + 'static)> {

match *self {

DoubleError::EmptyVec => None,

// The cause is the underlying implementation error type. Is implicitly

// cast to the trait object `&error::Error`. This works because the

// underlying type already implements the `Error` trait.

DoubleError::Parse(ref e) => Some(e),

}

}

}

// Implement the conversion from `ParseIntError` to `DoubleError`.

// This will be automatically called by `?` if a `ParseIntError`