?

Chaining results using match can get pretty untidy; luckily, the ? operator
can be used to make things pretty again. ? is used at the end of an expression
returning a Result, and is equivalent to a match expression, where the
Err(err) branch expands to an early Err(From::from(err)), and the Ok(ok)
branch expands to an ok expression.

  1. mod checked {
  2.     #[derive(Debug)]
  3.     enum MathError {
  4.         DivisionByZero,
  5.         NonPositiveLogarithm,
  6.         NegativeSquareRoot,
  7.     }
  9.     type MathResult = Result<f64, MathError>;
  11.     fn div(x: f64, y: f64) -> MathResult {
  12.         if y == 0.0 {
  13.             Err(MathError::DivisionByZero)
  14.         } else {
  15.             Ok(x / y)
  16.         }
  17.     }
  19.     fn sqrt(x: f64) -> MathResult {
  20.         if x < 0.0 {
  21.             Err(MathError::NegativeSquareRoot)
  22.         } else {
  23.             Ok(x.sqrt())
  24.         }
  25.     }
  27.     fn ln(x: f64) -> MathResult {
  28.         if x <= 0.0 {
  29.             Err(MathError::NonPositiveLogarithm)
  30.         } else {
  31.             Ok(x.ln())
  32.         }
  33.     }
  35.     // Intermediate function
  36.     fn op_(x: f64, y: f64) -> MathResult {
  37.         // if `div` "fails", then `DivisionByZero` will be `return`ed
  38.         let ratio = div(x, y)?;
  40.         // if `ln` "fails", then `NonPositiveLogarithm` will be `return`ed
  41.         let ln = ln(ratio)?;
  43.         sqrt(ln)
  44.     }
  46.     pub fn op(x: f64, y: f64) {
  47.         match op_(x, y) {
  48.             Err(why) => panic!(match why {
  49.                 MathError::NonPositiveLogarithm
  50.                     => "logarithm of non-positive number",
  51.                 MathError::DivisionByZero
  52.                     => "division by zero",
  53.                 MathError::NegativeSquareRoot
  54.                     => "square root of negative number",
  55.             }),
  56.             Ok(value) => println!("{}", value),
  57.         }
  58.     }
  59. }
  61. fn main() {
  62.     checked::op(1.0, 10.0);
  63. }

Be sure to check the documentation,
as there are many methods to map/compose Result.