anyhow

The anyhow crate provides a rich error type with support for carrying additional contextual information, which can be used to provide a semantic trace of what the program was doing leading up to the error.

This can be combined with the convenience macros from thiserror to avoid writing out trait impls explicitly for custom error types.

  1. use anyhow::{bail, Context, Result};
  2. use std::fs;
  3. use std::io::Read;
  4. use thiserror::Error;
  6. #[derive(Clone, Debug, Eq, Error, PartialEq)]
  7. #[error("Found no username in {0}")]
  8. struct EmptyUsernameError(String);
  10. fn read_username(path: &str) -> Result<String> {
  11.     let mut username = String::with_capacity(100);
  12.     fs::File::open(path)
  13.         .with_context(|| format!("Failed to open {path}"))?
  14.         .read_to_string(&mut username)
  15.         .context("Failed to read")?;
  16.     if username.is_empty() {
  17.         bail!(EmptyUsernameError(path.to_string()));
  18.     }
  19.     Ok(username)
  20. }
  22. fn main() {
  23.     //fs::write("config.dat", "").unwrap();
  24.     match read_username("config.dat") {
  25.         Ok(username) => println!("Username: {username}"),
  26.         Err(err) => println!("Error: {err:?}"),
  27.     }
  28. }

This slide should take about 5 minutes.

  • anyhow::Error is essentially a wrapper around Box<dyn Error>. As such it’s again generally not a good choice for the public API of a library, but is widely used in applications.
  • anyhow::Result<V> is a type alias for Result<V, anyhow::Error>.
  • Functionality provided by anyhow::Error may be familiar to Go developers, as it provides similar behavior to the Go error type and Result<T, anyhow::Error> is much like a Go (T, error) (with the convention that only one element of the pair is meaningful).
  • anyhow::Context is a trait implemented for the standard Result and Option types. use anyhow::Context is necessary to enable .context() and .with_context() on those types.

More to Explore

  • anyhow::Error has support for downcasting, much like std::any::Any; the specific error type stored inside can be extracted for examination if desired with Error::downcast.