aliases for Result: Custome Exception

How about when we want to reuse a specific Result type many times?

Recall that Rust allows us to create aliases. Conveniently, we can define one for the specific Result in question.

At a module level, creating aliases can be particularly helpful:

  • Errors found in a specific module often have the same Err type, so a single alias can succinctly define all associated Results.
  • This is so useful that the std library even supplies one: io::Result!

Here’s a quick example to show off the syntax:

 
use std::num::ParseIntError;

// Define a generic alias for a `Result` with the error type `ParseIntError`.
type AliasedResult<T> = Result<T, ParseIntError>;

// Use the above alias to refer to our specific `Result` type.
fn multiply(first_number_str: &str, second_number_str: &str) -> AliasedResult<i32> {
    first_number_str.parse::<i32>().and_then(|first_number| {
        second_number_str.parse::<i32>().map(|second_number| first_number * second_number)
    })
}

// Here, the alias again allows us to save some space.
fn print(result: AliasedResult<i32>) {
    match result {
        Ok(n)  => println!("n is {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

fn main() {
    print(multiply("10", "2"));
    print(multiply("t", "2"));
}
  1. Define a generic alias for a Result with the error type ParseIntError.
  2. Use the above alias to refer to our specific Result type.
  3. Here, the alias again allows us to save some space.

See also:

io::Result