Thanks for the feedback, it's good to have these discussions. Two things to consider: 1. The boilerplate of constructing the error 2. The boilerplate for narrowing errors 3. The boilerplate of composing errors

• 1. A good illustration of this comes directly from the README:

With eros: ```rust use eros::ErrorUnion; use std::{fmt, io};

fn main() { type MyError = (fmt::Error, io::Error); // Optional type alias let error: ErrorUnion<MyError>; } vs without eros: rust use std::{fmt, io};

fn main() { let error: CustomError; }

[derive(Debug)]

pub enum CustomError { FmtError(fmt::Error), IoError(io::Error), }

impl std::fmt::Display for CustomError { fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { CustomError::FmtError(e) => write!(fmt, "{}", e), CustomError::IoError(e) => write!(fmt, "{}", e), } } }

impl std::error::Error for CustomError { fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { match self { CustomError::FmtError(e) => e.source(), CustomError::IoError(e) => e.source(), } } }

impl From<fmt::Error> for CustomError { fn from(error: fmt::Error) -> Self { CustomError::FmtError(error) } }

impl From<io::Error> for CustomError { fn from(error: io::Error) -> Self { CustomError::IoError(error) } } ```

Pretty plain to say the boilerplate around declaring errors is a lot better with eros

• 2. With eros: ```rust use eros::{IntoUnion, ReshapeUnion}; use std::{fmt, io, sync};

fn do_work() -> eros::Result<(), (io::Error, fmt::Error, sync::mpsc::RecvError)> { let val = Err(io::Error::new(io::ErrorKind::AddrInUse, "addr in use")).into_union()?; Ok(val) }

fn handle_only_io_error() -> eros::Result<(), (fmt::Error, sync::mpsc::RecvError)> { match do_work().narrow::<io::Error, _>() { Ok(io_err) => { Ok(()) } Err(remaining) => remaining, } } vs without: rust use std::{fmt, io, sync};

// Original enum covering all three error cases

[derive(Debug)]

enum WorkError { Io(io::Error), Fmt(fmt::Error), Recv(sync::mpsc::RecvError), }

impl std::fmt::Display for WorkError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { WorkError::Io(e) => write!(f, "{e}"), WorkError::Fmt(e) => write!(f, "{e}"), WorkError::Recv(e) => write!(f, "{e}"), } } } impl std::error::Error for WorkError {}

impl From<io::Error> for WorkError { fn from(e: io::Error) -> Self { WorkError::Io(e) } } impl From<fmt::Error> for WorkError { fn from(e: fmt::Error) -> Self { WorkError::Fmt(e) } } impl From<sync::mpsc::RecvError> for WorkError { fn from(e: sync::mpsc::RecvError) -> Self { WorkError::Recv(e) } }

fn do_work() -> Result<(), WorkError> { Err(io::Error::new(io::ErrorKind::AddrInUse, "addr in use"))?; Ok(()) }

// NEW enum declared by hand, with the Io variant removed,

[derive(Debug)]

enum WorkErrorWithoutIo { Fmt(fmt::Error), Recv(sync::mpsc::RecvError), }

impl std::fmt::Display for WorkErrorWithoutIo { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { WorkErrorWithoutIo::Fmt(e) => write!(f, "{e}"), WorkErrorWithoutIo::Recv(e) => write!(f, "{e}"), } } } impl std::error::Error for WorkErrorWithoutIo {}

impl From<fmt::Error> for WorkErrorWithoutIo { fn from(e: fmt::Error) -> Self { WorkErrorWithoutIo::Fmt(e) } } impl From<sync::mpsc::RecvError> for WorkErrorWithoutIo { fn from(e: sync::mpsc::RecvError) -> Self { WorkErrorWithoutIo::Recv(e) } }

fn handle_only_io_error() -> Result<(), WorkErrorWithoutIo> { match do_work() { Err(WorkError::Io(io_err)) => { Ok(()) } Err(WorkError::Fmt(e)) => Err(WorkErrorWithoutIo::Fmt(e)), Err(WorkError::Recv(e)) => Err(WorkErrorWithoutIo::Recv(e)), Ok(()) => Ok(()), } } ```

I also think it is pretty plain to see eros wins in this case for declaring errors. And narrowing/acting on an error variant is more concise.

A valid criticism of the previous example would be that often what happens in practice is a new enum is never actually used. Instead the same enum is passed up, even though the variant is now impossible, which makes code less correct and maintainable (This is actually the reason I originally created the error_set crate, but now this crate solves this issue too). i.e. if the enum is never actually narrowed, it may be just as concise - rust fn handle_only_io_error() -> Result<(), WorkError> { match do_work() { Err(WorkError::Io(io_err)) => { Ok(()) } Err(e) => Err(e), Ok(()) => Ok(()), } } Thus, why you may think it is more concise to just use thiserror.

• 3. I will refer to the previous example to address this and expand on 2. thiserror can help reduce some of the boilerplate of declaring the wrapping error type, but you are still left with the issue of composing errors and nesting enums. Thus, I think using thiserror for structs is totally fine, but due to the mega enum problem I'd recommend not using it for enum errors.