u/InternalServerError7

A few months ago we introduced eros. Eros is the only error handling crate you'll ever need for libraries or binaries. It is built on four philosophies — error types should only matter when you care about them, no boilerplate for handling any number of errors, seamless transitions between typed and untyped errors, and errors should always carry context.

Today we are releasing releasing 0.6, which is the biggest change to the crate yet.

The biggest change: TracedError is gone

In 0.5, you had two core types: TracedError<T> for tracing/context, and ErrorUnion<T> for combining multiple error types.

In 0.6, ErrorUnion absorbs everything TracedError did. There's just one type now. Tracing, context, and backtraces are all built directly into ErrorUnion. This greatly increases composability.

use eros::{Context, IntoUnion};
use std::{io, sync};

fn regular_typed_result1() -> Result<(), io::Error> {
    Err(io::Error::new(io::ErrorKind::AddrInUse, "message here"))
}

fn regular_typed_result2() -> Result<(), sync::mpsc::RecvError> {
    Err(sync::mpsc::RecvError)
}

fn error_union_result() -> eros::Result<(), (io::Error, sync::mpsc::RecvError)> {
    let val = regular_typed_result1().into_union()?;
    let val = regular_typed_result2().into_union()?;
    Ok(val)
}

fn erased_result() -> eros::Result<()> {
    regular_typed_result1().context("Some context")?;
    error_union_result()?;
    Ok(())
}

ErrorUnion is explained in greater detail here

New: the #[context] macro

The most repetitive part of using eros was writing .with_context(...) after every fallible call in a function, especially when the context was basically the same each time. Now you can annotate the function itself:

#[eros::context("param was {}", param)]
fn context_added_once(param: &str) -> eros::Result<()> {
    result()?;
    result()?;
    result()?;
    Ok(())
}

This adds the same context to any error escaping the function, without cluttering the call sites. There's also an automatic mode where you annotate parameters with #[fmt(...)] and the context gets generated from the function signature itself — useful when the question you're answering is just "what arguments was this called with?"

Other notable additions:

• location feature flag — lighter-weight alternative/complement to backtrace, captured at compile time, works in WASM where backtraces don't
• better_backtrace feature flag for much more readable backtraces during development
• AnyError for representing "could be any error" without listing out every type
• Easier migration path from anyhow (mostly find-and-replace)
• Logging integration — a logging feature flag adds log_error()/log_warn()/etc. directly on ErrorUnion and a LogExt trait for chaining on Result. Optional tracing backend support included.
• User-facing error messages — a user_context feature lets you mark specific context as "safe to show the user," so you can build clean user-facing messages without leaking internal details like file paths or SQL queries.

0.6 makes the crate considerably easier to pick up than 0.5, while being more powerful.

The README has a full walkthrough, and feedback/criticism is welcome: https://github.com/mcmah309/eros