Rust中处理Result类型的match匹配是否有简写形式？

Absolutely feel your pain—writing full match blocks for every Result can feel unnecessarily verbose when you're just trying to get something simple done. Rust has several handy shortcuts to clean this up, depending on what you need to do with the error case. Here are the most common ones:

1. unwrap() and expect() (Quick Panic on Error) #

You're already using unwrap(), which is the simplest shortcut—it directly unwraps the Ok value, or panics if it's an Err. For better debuggability, swap it with expect() to add a custom error message that makes panic logs easier to understand:

let elapsed = now.elapsed().expect("Failed to calculate elapsed time");
println!("Thread 1 :: Exiting...after {:?}s ", elapsed);

Use this when you're confident the operation won't fail (e.g., in small scripts, tests, or cases where failure is a catastrophic bug that shouldn't happen).

2. if let Syntax (Handle Only the Ok Case) #

If you don't need to handle the error in detail (or just want a minimal error branch), if let lets you skip the full match and only target the Ok variant:

if let Ok(elapsed) = now.elapsed() {
    println!("Thread 1 :: Exiting...after {:?}s ", elapsed);
}
// Optional: Add an else block if you need to acknowledge errors briefly
else {
    eprintln!("Oops, couldn't calculate time elapsed!");
}

This cuts down on boilerplate while keeping your code's intent clear.

3. The ? Operator (Propagate Errors Upwards) #

If your code lives inside a function that returns a Result itself, the ? operator is your best friend. It automatically unwraps Ok values, and if it hits an Err, it immediately returns that error from the function (no match required):

use std::time::{SystemTime, Duration};
use std::sync::Condvar;

fn run_thread_task(cvar: &Condvar, started: &mut bool) -> Result<(), Box<dyn std::error::Error>> {
    let now = SystemTime::now();
    
    // Use ? to unwrap or return the error to the caller
    let result = cvar.wait_timeout(started, Duration::from_millis(20000))?;
    *started = result.0;
    if !*started {
        *started = true;
    }

    let elapsed = now.elapsed()?;
    println!("Thread 1 :: Exiting...after {:?}s ", elapsed);
    
    Ok(())
}

This keeps your code clean and lets upper-level code handle errors (if needed) instead of cluttering your business logic.

4. unwrap_or() / unwrap_or_else() (Fallback to a Default Value) #

If you want to provide a fallback value when the operation fails, use these methods:

• unwrap_or() takes a static default value:

  let elapsed = now.elapsed().unwrap_or(Duration::from_secs(0));
  println!("Thread 1 :: Exiting...after {:?}s ", elapsed);
  

• unwrap_or_else() uses a closure to compute a dynamic default (great if you need to log the error first):

  let elapsed = now.elapsed().unwrap_or_else(|err| {
      eprintln!("Error getting elapsed time: {:?}", err);
      Duration::from_secs(0)
  });
  

Choosing the Right Shortcut #

• Use unwrap()/expect() for quick scripts or when failure is unrecoverable.
• Use if let when you only care about success (or want minimal error handling).
• Use ? when working in a function that returns Result (keeps error handling centralized).
• Use unwrap_or()/unwrap_or_else() when you need a fallback value for failures.

内容的提问来源于stack exchange，提问作者Rajeev Ranjan