error_set 0.3.1

An error set macro that provides a concise way to define errors and ergonomically coerce between sets. Inspired by Zig's error set type.
Documentation

error_set

A concise way to define errors and ergonomically coerce a subset into a superset with with just .into() or ?, and coerce between intersecting sets with coerce!.

error_set was inspired by zig's error set and works functionally the same.

Instead of defining various enums/structs for errors and hand rolling relations, use an error set:

use error_set::error_set;

error_set! {
    MediaError = {
        IoError(std::io::Error)
    } || BookParsingError || DownloadError || ParseUploadError;
    BookParsingError = {
        MissingBookDescription,
        CouldNotReadBook(std::io::Error),
    } || BookSectionParsingError;
    BookSectionParsingError = {
        MissingName,
        NoContents,
    };
    DownloadError = {
        InvalidUrl,
        CouldNotSaveBook(std::io::Error),
    };
    ParseUploadError = {
        MaximumUploadSizeReached,
        TimedOut,
        AuthenticationFailed,
    };
}

#![feature(prelude_import)]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
pub enum MediaError {
    IoError(std::io::Error),
    MissingBookDescription,
    MissingName,
    NoContents,
    InvalidUrl,
    MaximumUploadSizeReached,
    TimedOut,
    AuthenticationFailed,
}
#[automatically_derived]
impl ::core::fmt::Debug for MediaError {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            MediaError::IoError(__self_0) => {
                ::core::fmt::Formatter::debug_tuple_field1_finish(
                    f,
                    "IoError",
                    &__self_0,
                )
            }
            MediaError::MissingBookDescription => {
                ::core::fmt::Formatter::write_str(f, "MissingBookDescription")
            }
            MediaError::MissingName => {
                ::core::fmt::Formatter::write_str(f, "MissingName")
            }
            MediaError::NoContents => ::core::fmt::Formatter::write_str(f, "NoContents"),
            MediaError::InvalidUrl => ::core::fmt::Formatter::write_str(f, "InvalidUrl"),
            MediaError::MaximumUploadSizeReached => {
                ::core::fmt::Formatter::write_str(f, "MaximumUploadSizeReached")
            }
            MediaError::TimedOut => ::core::fmt::Formatter::write_str(f, "TimedOut"),
            MediaError::AuthenticationFailed => {
                ::core::fmt::Formatter::write_str(f, "AuthenticationFailed")
            }
        }
    }
}
impl error_set::ErrorSetMarker for MediaError {}
#[allow(unused_qualifications)]
impl std::error::Error for MediaError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match *self {
            MediaError::IoError(ref source) => source.source(),
            #[allow(unreachable_patterns)]
            _ => None,
        }
    }
}
impl core::fmt::Display for MediaError {
    #[inline]
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        let variant_name = match *self {
            MediaError::IoError(_) => "MediaError::IoError",
            MediaError::MissingBookDescription => "MediaError::MissingBookDescription",
            MediaError::MissingName => "MediaError::MissingName",
            MediaError::NoContents => "MediaError::NoContents",
            MediaError::InvalidUrl => "MediaError::InvalidUrl",
            MediaError::MaximumUploadSizeReached => {
                "MediaError::MaximumUploadSizeReached"
            }
            MediaError::TimedOut => "MediaError::TimedOut",
            MediaError::AuthenticationFailed => "MediaError::AuthenticationFailed",
        };
        f.write_fmt(format_args!("{0}", variant_name))
    }
}
impl From<BookParsingError> for MediaError {
    fn from(error: BookParsingError) -> Self {
        match error {
            BookParsingError::MissingBookDescription => {
                MediaError::MissingBookDescription
            }
            BookParsingError::CouldNotReadBook(source) => MediaError::IoError(source),
            BookParsingError::MissingName => MediaError::MissingName,
            BookParsingError::NoContents => MediaError::NoContents,
        }
    }
}
impl From<BookSectionParsingError> for MediaError {
    fn from(error: BookSectionParsingError) -> Self {
        match error {
            BookSectionParsingError::MissingName => MediaError::MissingName,
            BookSectionParsingError::NoContents => MediaError::NoContents,
        }
    }
}
impl From<DownloadError> for MediaError {
    fn from(error: DownloadError) -> Self {
        match error {
            DownloadError::InvalidUrl => MediaError::InvalidUrl,
            DownloadError::CouldNotSaveBook(source) => MediaError::IoError(source),
        }
    }
}
impl From<ParseUploadError> for MediaError {
    fn from(error: ParseUploadError) -> Self {
        match error {
            ParseUploadError::MaximumUploadSizeReached => {
                MediaError::MaximumUploadSizeReached
            }
            ParseUploadError::TimedOut => MediaError::TimedOut,
            ParseUploadError::AuthenticationFailed => MediaError::AuthenticationFailed,
        }
    }
}
impl From<std::io::Error> for MediaError {
    fn from(error: std::io::Error) -> Self {
        MediaError::IoError(error)
    }
}
pub enum BookParsingError {
    MissingBookDescription,
    CouldNotReadBook(std::io::Error),
    MissingName,
    NoContents,
}
#[automatically_derived]
impl ::core::fmt::Debug for BookParsingError {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            BookParsingError::MissingBookDescription => {
                ::core::fmt::Formatter::write_str(f, "MissingBookDescription")
            }
            BookParsingError::CouldNotReadBook(__self_0) => {
                ::core::fmt::Formatter::debug_tuple_field1_finish(
                    f,
                    "CouldNotReadBook",
                    &__self_0,
                )
            }
            BookParsingError::MissingName => {
                ::core::fmt::Formatter::write_str(f, "MissingName")
            }
            BookParsingError::NoContents => {
                ::core::fmt::Formatter::write_str(f, "NoContents")
            }
        }
    }
}
impl error_set::ErrorSetMarker for BookParsingError {}
#[allow(unused_qualifications)]
impl std::error::Error for BookParsingError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match *self {
            BookParsingError::CouldNotReadBook(ref source) => source.source(),
            #[allow(unreachable_patterns)]
            _ => None,
        }
    }
}
impl core::fmt::Display for BookParsingError {
    #[inline]
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        let variant_name = match *self {
            BookParsingError::MissingBookDescription => {
                "BookParsingError::MissingBookDescription"
            }
            BookParsingError::CouldNotReadBook(_) => "BookParsingError::CouldNotReadBook",
            BookParsingError::MissingName => "BookParsingError::MissingName",
            BookParsingError::NoContents => "BookParsingError::NoContents",
        };
        f.write_fmt(format_args!("{0}", variant_name))
    }
}
impl From<BookSectionParsingError> for BookParsingError {
    fn from(error: BookSectionParsingError) -> Self {
        match error {
            BookSectionParsingError::MissingName => BookParsingError::MissingName,
            BookSectionParsingError::NoContents => BookParsingError::NoContents,
        }
    }
}
impl From<std::io::Error> for BookParsingError {
    fn from(error: std::io::Error) -> Self {
        BookParsingError::CouldNotReadBook(error)
    }
}
pub enum BookSectionParsingError {
    MissingName,
    NoContents,
}
#[automatically_derived]
impl ::core::fmt::Debug for BookSectionParsingError {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(
            f,
            match self {
                BookSectionParsingError::MissingName => "MissingName",
                BookSectionParsingError::NoContents => "NoContents",
            },
        )
    }
}
impl error_set::ErrorSetMarker for BookSectionParsingError {}
#[allow(unused_qualifications)]
impl std::error::Error for BookSectionParsingError {}
impl core::fmt::Display for BookSectionParsingError {
    #[inline]
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        let variant_name = match *self {
            BookSectionParsingError::MissingName => {
                "BookSectionParsingError::MissingName"
            }
            BookSectionParsingError::NoContents => "BookSectionParsingError::NoContents",
        };
        f.write_fmt(format_args!("{0}", variant_name))
    }
}
pub enum DownloadError {
    InvalidUrl,
    CouldNotSaveBook(std::io::Error),
}
#[automatically_derived]
impl ::core::fmt::Debug for DownloadError {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            DownloadError::InvalidUrl => {
                ::core::fmt::Formatter::write_str(f, "InvalidUrl")
            }
            DownloadError::CouldNotSaveBook(__self_0) => {
                ::core::fmt::Formatter::debug_tuple_field1_finish(
                    f,
                    "CouldNotSaveBook",
                    &__self_0,
                )
            }
        }
    }
}
impl error_set::ErrorSetMarker for DownloadError {}
#[allow(unused_qualifications)]
impl std::error::Error for DownloadError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match *self {
            DownloadError::CouldNotSaveBook(ref source) => source.source(),
            #[allow(unreachable_patterns)]
            _ => None,
        }
    }
}
impl core::fmt::Display for DownloadError {
    #[inline]
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        let variant_name = match *self {
            DownloadError::InvalidUrl => "DownloadError::InvalidUrl",
            DownloadError::CouldNotSaveBook(_) => "DownloadError::CouldNotSaveBook",
        };
        f.write_fmt(format_args!("{0}", variant_name))
    }
}
impl From<std::io::Error> for DownloadError {
    fn from(error: std::io::Error) -> Self {
        DownloadError::CouldNotSaveBook(error)
    }
}
pub enum ParseUploadError {
    MaximumUploadSizeReached,
    TimedOut,
    AuthenticationFailed,
}
#[automatically_derived]
impl ::core::fmt::Debug for ParseUploadError {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(
            f,
            match self {
                ParseUploadError::MaximumUploadSizeReached => "MaximumUploadSizeReached",
                ParseUploadError::TimedOut => "TimedOut",
                ParseUploadError::AuthenticationFailed => "AuthenticationFailed",
            },
        )
    }
}
impl error_set::ErrorSetMarker for ParseUploadError {}
#[allow(unused_qualifications)]
impl std::error::Error for ParseUploadError {}
impl core::fmt::Display for ParseUploadError {
    #[inline]
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        let variant_name = match *self {
            ParseUploadError::MaximumUploadSizeReached => {
                "ParseUploadError::MaximumUploadSizeReached"
            }
            ParseUploadError::TimedOut => "ParseUploadError::TimedOut",
            ParseUploadError::AuthenticationFailed => {
                "ParseUploadError::AuthenticationFailed"
            }
        };
        f.write_fmt(format_args!("{0}", variant_name))
    }
}
#[allow(unused_macros)]
macro_rules! coerce {
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(MediaError) => return Err(MediaError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(MediaError::IoError(source)) => {
        return Err(MediaError::IoError(source));
      },Err(MediaError::MissingBookDescription) => {
        return Err(MediaError::MissingBookDescription);
      },Err(MediaError::MissingName) => {
        return Err(MediaError::MissingName);
      },Err(MediaError::NoContents) => {
        return Err(MediaError::NoContents);
      },Err(MediaError::InvalidUrl) => {
        return Err(MediaError::InvalidUrl);
      },Err(MediaError::MaximumUploadSizeReached) => {
        return Err(MediaError::MaximumUploadSizeReached);
      },Err(MediaError::TimedOut) => {
        return Err(MediaError::TimedOut);
      },Err(MediaError::AuthenticationFailed) => {
        return Err(MediaError::AuthenticationFailed);
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(MediaError) => Err(MediaError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(MediaError::IoError(source)) => {
        Err(MediaError::IoError(source))
      },Err(MediaError::MissingBookDescription) => {
        Err(MediaError::MissingBookDescription)
      },Err(MediaError::MissingName) => {
        Err(MediaError::MissingName)
      },Err(MediaError::NoContents) => {
        Err(MediaError::NoContents)
      },Err(MediaError::InvalidUrl) => {
        Err(MediaError::InvalidUrl)
      },Err(MediaError::MaximumUploadSizeReached) => {
        Err(MediaError::MaximumUploadSizeReached)
      },Err(MediaError::TimedOut) => {
        Err(MediaError::TimedOut)
      },Err(MediaError::AuthenticationFailed) => {
        Err(MediaError::AuthenticationFailed)
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||MediaError => return MediaError) => {
    match$expr {
      $($patterns =>  $results,)+MediaError::IoError(source) => {
        return MediaError::IoError(source);
      },MediaError::MissingBookDescription => {
        return MediaError::MissingBookDescription;
      },MediaError::MissingName => {
        return MediaError::MissingName;
      },MediaError::NoContents => {
        return MediaError::NoContents;
      },MediaError::InvalidUrl => {
        return MediaError::InvalidUrl;
      },MediaError::MaximumUploadSizeReached => {
        return MediaError::MaximumUploadSizeReached;
      },MediaError::TimedOut => {
        return MediaError::TimedOut;
      },MediaError::AuthenticationFailed => {
        return MediaError::AuthenticationFailed;
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||MediaError => MediaError) => {
    match$expr {
      $($patterns =>  $results,)+MediaError::IoError(source) => {
        MediaError::IoError(source)
      },MediaError::MissingBookDescription => {
        MediaError::MissingBookDescription
      },MediaError::MissingName => {
        MediaError::MissingName
      },MediaError::NoContents => {
        MediaError::NoContents
      },MediaError::InvalidUrl => {
        MediaError::InvalidUrl
      },MediaError::MaximumUploadSizeReached => {
        MediaError::MaximumUploadSizeReached
      },MediaError::TimedOut => {
        MediaError::TimedOut
      },MediaError::AuthenticationFailed => {
        MediaError::AuthenticationFailed
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(MediaError) => return Err(BookParsingError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(MediaError::IoError(source)) => {
        return Err(BookParsingError::IoError(source));
      },Err(MediaError::MissingBookDescription) => {
        return Err(BookParsingError::MissingBookDescription);
      },Err(MediaError::MissingName) => {
        return Err(BookParsingError::MissingName);
      },Err(MediaError::NoContents) => {
        return Err(BookParsingError::NoContents);
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(MediaError) => Err(BookParsingError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(MediaError::IoError(source)) => {
        Err(BookParsingError::IoError(source))
      },Err(MediaError::MissingBookDescription) => {
        Err(BookParsingError::MissingBookDescription)
      },Err(MediaError::MissingName) => {
        Err(BookParsingError::MissingName)
      },Err(MediaError::NoContents) => {
        Err(BookParsingError::NoContents)
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||MediaError => return BookParsingError) => {
    match$expr {
      $($patterns =>  $results,)+MediaError::IoError(source) => {
        return BookParsingError::IoError(source);
      },MediaError::MissingBookDescription => {
        return BookParsingError::MissingBookDescription;
      },MediaError::MissingName => {
        return BookParsingError::MissingName;
      },MediaError::NoContents => {
        return BookParsingError::NoContents;
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||MediaError => BookParsingError) => {
    match$expr {
      $($patterns =>  $results,)+MediaError::IoError(source) => {
        BookParsingError::IoError(source)
      },MediaError::MissingBookDescription => {
        BookParsingError::MissingBookDescription
      },MediaError::MissingName => {
        BookParsingError::MissingName
      },MediaError::NoContents => {
        BookParsingError::NoContents
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(MediaError) => return Err(BookSectionParsingError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(MediaError::MissingName) => {
        return Err(BookSectionParsingError::MissingName);
      },Err(MediaError::NoContents) => {
        return Err(BookSectionParsingError::NoContents);
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(MediaError) => Err(BookSectionParsingError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(MediaError::MissingName) => {
        Err(BookSectionParsingError::MissingName)
      },Err(MediaError::NoContents) => {
        Err(BookSectionParsingError::NoContents)
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||MediaError => return BookSectionParsingError) => {
    match$expr {
      $($patterns =>  $results,)+MediaError::MissingName => {
        return BookSectionParsingError::MissingName;
      },MediaError::NoContents => {
        return BookSectionParsingError::NoContents;
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||MediaError => BookSectionParsingError) => {
    match$expr {
      $($patterns =>  $results,)+MediaError::MissingName => {
        BookSectionParsingError::MissingName
      },MediaError::NoContents => {
        BookSectionParsingError::NoContents
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(MediaError) => return Err(DownloadError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(MediaError::IoError(source)) => {
        return Err(DownloadError::IoError(source));
      },Err(MediaError::InvalidUrl) => {
        return Err(DownloadError::InvalidUrl);
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(MediaError) => Err(DownloadError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(MediaError::IoError(source)) => {
        Err(DownloadError::IoError(source))
      },Err(MediaError::InvalidUrl) => {
        Err(DownloadError::InvalidUrl)
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||MediaError => return DownloadError) => {
    match$expr {
      $($patterns =>  $results,)+MediaError::IoError(source) => {
        return DownloadError::IoError(source);
      },MediaError::InvalidUrl => {
        return DownloadError::InvalidUrl;
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||MediaError => DownloadError) => {
    match$expr {
      $($patterns =>  $results,)+MediaError::IoError(source) => {
        DownloadError::IoError(source)
      },MediaError::InvalidUrl => {
        DownloadError::InvalidUrl
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(MediaError) => return Err(ParseUploadError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(MediaError::MaximumUploadSizeReached) => {
        return Err(ParseUploadError::MaximumUploadSizeReached);
      },Err(MediaError::TimedOut) => {
        return Err(ParseUploadError::TimedOut);
      },Err(MediaError::AuthenticationFailed) => {
        return Err(ParseUploadError::AuthenticationFailed);
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(MediaError) => Err(ParseUploadError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(MediaError::MaximumUploadSizeReached) => {
        Err(ParseUploadError::MaximumUploadSizeReached)
      },Err(MediaError::TimedOut) => {
        Err(ParseUploadError::TimedOut)
      },Err(MediaError::AuthenticationFailed) => {
        Err(ParseUploadError::AuthenticationFailed)
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||MediaError => return ParseUploadError) => {
    match$expr {
      $($patterns =>  $results,)+MediaError::MaximumUploadSizeReached => {
        return ParseUploadError::MaximumUploadSizeReached;
      },MediaError::TimedOut => {
        return ParseUploadError::TimedOut;
      },MediaError::AuthenticationFailed => {
        return ParseUploadError::AuthenticationFailed;
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||MediaError => ParseUploadError) => {
    match$expr {
      $($patterns =>  $results,)+MediaError::MaximumUploadSizeReached => {
        ParseUploadError::MaximumUploadSizeReached
      },MediaError::TimedOut => {
        ParseUploadError::TimedOut
      },MediaError::AuthenticationFailed => {
        ParseUploadError::AuthenticationFailed
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(BookParsingError) => return Err(MediaError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(BookParsingError::MissingBookDescription) => {
        return Err(MediaError::MissingBookDescription);
      },Err(BookParsingError::CouldNotReadBook(source)) => {
        return Err(MediaError::CouldNotReadBook(source));
      },Err(BookParsingError::MissingName) => {
        return Err(MediaError::MissingName);
      },Err(BookParsingError::NoContents) => {
        return Err(MediaError::NoContents);
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(BookParsingError) => Err(MediaError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(BookParsingError::MissingBookDescription) => {
        Err(MediaError::MissingBookDescription)
      },Err(BookParsingError::CouldNotReadBook(source)) => {
        Err(MediaError::CouldNotReadBook(source))
      },Err(BookParsingError::MissingName) => {
        Err(MediaError::MissingName)
      },Err(BookParsingError::NoContents) => {
        Err(MediaError::NoContents)
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||BookParsingError => return MediaError) => {
    match$expr {
      $($patterns =>  $results,)+BookParsingError::MissingBookDescription => {
        return MediaError::MissingBookDescription;
      },BookParsingError::CouldNotReadBook(source) => {
        return MediaError::CouldNotReadBook(source);
      },BookParsingError::MissingName => {
        return MediaError::MissingName;
      },BookParsingError::NoContents => {
        return MediaError::NoContents;
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||BookParsingError => MediaError) => {
    match$expr {
      $($patterns =>  $results,)+BookParsingError::MissingBookDescription => {
        MediaError::MissingBookDescription
      },BookParsingError::CouldNotReadBook(source) => {
        MediaError::CouldNotReadBook(source)
      },BookParsingError::MissingName => {
        MediaError::MissingName
      },BookParsingError::NoContents => {
        MediaError::NoContents
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(BookParsingError) => return Err(BookParsingError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(BookParsingError::MissingBookDescription) => {
        return Err(BookParsingError::MissingBookDescription);
      },Err(BookParsingError::CouldNotReadBook(source)) => {
        return Err(BookParsingError::CouldNotReadBook(source));
      },Err(BookParsingError::MissingName) => {
        return Err(BookParsingError::MissingName);
      },Err(BookParsingError::NoContents) => {
        return Err(BookParsingError::NoContents);
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(BookParsingError) => Err(BookParsingError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(BookParsingError::MissingBookDescription) => {
        Err(BookParsingError::MissingBookDescription)
      },Err(BookParsingError::CouldNotReadBook(source)) => {
        Err(BookParsingError::CouldNotReadBook(source))
      },Err(BookParsingError::MissingName) => {
        Err(BookParsingError::MissingName)
      },Err(BookParsingError::NoContents) => {
        Err(BookParsingError::NoContents)
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||BookParsingError => return BookParsingError) => {
    match$expr {
      $($patterns =>  $results,)+BookParsingError::MissingBookDescription => {
        return BookParsingError::MissingBookDescription;
      },BookParsingError::CouldNotReadBook(source) => {
        return BookParsingError::CouldNotReadBook(source);
      },BookParsingError::MissingName => {
        return BookParsingError::MissingName;
      },BookParsingError::NoContents => {
        return BookParsingError::NoContents;
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||BookParsingError => BookParsingError) => {
    match$expr {
      $($patterns =>  $results,)+BookParsingError::MissingBookDescription => {
        BookParsingError::MissingBookDescription
      },BookParsingError::CouldNotReadBook(source) => {
        BookParsingError::CouldNotReadBook(source)
      },BookParsingError::MissingName => {
        BookParsingError::MissingName
      },BookParsingError::NoContents => {
        BookParsingError::NoContents
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(BookParsingError) => return Err(BookSectionParsingError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(BookParsingError::MissingName) => {
        return Err(BookSectionParsingError::MissingName);
      },Err(BookParsingError::NoContents) => {
        return Err(BookSectionParsingError::NoContents);
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(BookParsingError) => Err(BookSectionParsingError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(BookParsingError::MissingName) => {
        Err(BookSectionParsingError::MissingName)
      },Err(BookParsingError::NoContents) => {
        Err(BookSectionParsingError::NoContents)
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||BookParsingError => return BookSectionParsingError) => {
    match$expr {
      $($patterns =>  $results,)+BookParsingError::MissingName => {
        return BookSectionParsingError::MissingName;
      },BookParsingError::NoContents => {
        return BookSectionParsingError::NoContents;
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||BookParsingError => BookSectionParsingError) => {
    match$expr {
      $($patterns =>  $results,)+BookParsingError::MissingName => {
        BookSectionParsingError::MissingName
      },BookParsingError::NoContents => {
        BookSectionParsingError::NoContents
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(BookParsingError) => return Err(DownloadError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(BookParsingError::CouldNotReadBook(source)) => {
        return Err(DownloadError::CouldNotReadBook(source));
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(BookParsingError) => Err(DownloadError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(BookParsingError::CouldNotReadBook(source)) => {
        Err(DownloadError::CouldNotReadBook(source))
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||BookParsingError => return DownloadError) => {
    match$expr {
      $($patterns =>  $results,)+BookParsingError::CouldNotReadBook(source) => {
        return DownloadError::CouldNotReadBook(source);
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||BookParsingError => DownloadError) => {
    match$expr {
      $($patterns =>  $results,)+BookParsingError::CouldNotReadBook(source) => {
        DownloadError::CouldNotReadBook(source)
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(BookSectionParsingError) => return Err(MediaError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(BookSectionParsingError::MissingName) => {
        return Err(MediaError::MissingName);
      },Err(BookSectionParsingError::NoContents) => {
        return Err(MediaError::NoContents);
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(BookSectionParsingError) => Err(MediaError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(BookSectionParsingError::MissingName) => {
        Err(MediaError::MissingName)
      },Err(BookSectionParsingError::NoContents) => {
        Err(MediaError::NoContents)
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||BookSectionParsingError => return MediaError) => {
    match$expr {
      $($patterns =>  $results,)+BookSectionParsingError::MissingName => {
        return MediaError::MissingName;
      },BookSectionParsingError::NoContents => {
        return MediaError::NoContents;
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||BookSectionParsingError => MediaError) => {
    match$expr {
      $($patterns =>  $results,)+BookSectionParsingError::MissingName => {
        MediaError::MissingName
      },BookSectionParsingError::NoContents => {
        MediaError::NoContents
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(BookSectionParsingError) => return Err(BookParsingError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(BookSectionParsingError::MissingName) => {
        return Err(BookParsingError::MissingName);
      },Err(BookSectionParsingError::NoContents) => {
        return Err(BookParsingError::NoContents);
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(BookSectionParsingError) => Err(BookParsingError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(BookSectionParsingError::MissingName) => {
        Err(BookParsingError::MissingName)
      },Err(BookSectionParsingError::NoContents) => {
        Err(BookParsingError::NoContents)
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||BookSectionParsingError => return BookParsingError) => {
    match$expr {
      $($patterns =>  $results,)+BookSectionParsingError::MissingName => {
        return BookParsingError::MissingName;
      },BookSectionParsingError::NoContents => {
        return BookParsingError::NoContents;
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||BookSectionParsingError => BookParsingError) => {
    match$expr {
      $($patterns =>  $results,)+BookSectionParsingError::MissingName => {
        BookParsingError::MissingName
      },BookSectionParsingError::NoContents => {
        BookParsingError::NoContents
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(BookSectionParsingError) => return Err(BookSectionParsingError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(BookSectionParsingError::MissingName) => {
        return Err(BookSectionParsingError::MissingName);
      },Err(BookSectionParsingError::NoContents) => {
        return Err(BookSectionParsingError::NoContents);
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(BookSectionParsingError) => Err(BookSectionParsingError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(BookSectionParsingError::MissingName) => {
        Err(BookSectionParsingError::MissingName)
      },Err(BookSectionParsingError::NoContents) => {
        Err(BookSectionParsingError::NoContents)
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||BookSectionParsingError => return BookSectionParsingError) => {
    match$expr {
      $($patterns =>  $results,)+BookSectionParsingError::MissingName => {
        return BookSectionParsingError::MissingName;
      },BookSectionParsingError::NoContents => {
        return BookSectionParsingError::NoContents;
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||BookSectionParsingError => BookSectionParsingError) => {
    match$expr {
      $($patterns =>  $results,)+BookSectionParsingError::MissingName => {
        BookSectionParsingError::MissingName
      },BookSectionParsingError::NoContents => {
        BookSectionParsingError::NoContents
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(DownloadError) => return Err(MediaError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(DownloadError::InvalidUrl) => {
        return Err(MediaError::InvalidUrl);
      },Err(DownloadError::CouldNotSaveBook(source)) => {
        return Err(MediaError::CouldNotSaveBook(source));
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(DownloadError) => Err(MediaError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(DownloadError::InvalidUrl) => {
        Err(MediaError::InvalidUrl)
      },Err(DownloadError::CouldNotSaveBook(source)) => {
        Err(MediaError::CouldNotSaveBook(source))
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||DownloadError => return MediaError) => {
    match$expr {
      $($patterns =>  $results,)+DownloadError::InvalidUrl => {
        return MediaError::InvalidUrl;
      },DownloadError::CouldNotSaveBook(source) => {
        return MediaError::CouldNotSaveBook(source);
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||DownloadError => MediaError) => {
    match$expr {
      $($patterns =>  $results,)+DownloadError::InvalidUrl => {
        MediaError::InvalidUrl
      },DownloadError::CouldNotSaveBook(source) => {
        MediaError::CouldNotSaveBook(source)
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(DownloadError) => return Err(BookParsingError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(DownloadError::CouldNotSaveBook(source)) => {
        return Err(BookParsingError::CouldNotSaveBook(source));
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(DownloadError) => Err(BookParsingError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(DownloadError::CouldNotSaveBook(source)) => {
        Err(BookParsingError::CouldNotSaveBook(source))
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||DownloadError => return BookParsingError) => {
    match$expr {
      $($patterns =>  $results,)+DownloadError::CouldNotSaveBook(source) => {
        return BookParsingError::CouldNotSaveBook(source);
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||DownloadError => BookParsingError) => {
    match$expr {
      $($patterns =>  $results,)+DownloadError::CouldNotSaveBook(source) => {
        BookParsingError::CouldNotSaveBook(source)
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(DownloadError) => return Err(DownloadError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(DownloadError::InvalidUrl) => {
        return Err(DownloadError::InvalidUrl);
      },Err(DownloadError::CouldNotSaveBook(source)) => {
        return Err(DownloadError::CouldNotSaveBook(source));
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(DownloadError) => Err(DownloadError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(DownloadError::InvalidUrl) => {
        Err(DownloadError::InvalidUrl)
      },Err(DownloadError::CouldNotSaveBook(source)) => {
        Err(DownloadError::CouldNotSaveBook(source))
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||DownloadError => return DownloadError) => {
    match$expr {
      $($patterns =>  $results,)+DownloadError::InvalidUrl => {
        return DownloadError::InvalidUrl;
      },DownloadError::CouldNotSaveBook(source) => {
        return DownloadError::CouldNotSaveBook(source);
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||DownloadError => DownloadError) => {
    match$expr {
      $($patterns =>  $results,)+DownloadError::InvalidUrl => {
        DownloadError::InvalidUrl
      },DownloadError::CouldNotSaveBook(source) => {
        DownloadError::CouldNotSaveBook(source)
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(ParseUploadError) => return Err(MediaError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(ParseUploadError::MaximumUploadSizeReached) => {
        return Err(MediaError::MaximumUploadSizeReached);
      },Err(ParseUploadError::TimedOut) => {
        return Err(MediaError::TimedOut);
      },Err(ParseUploadError::AuthenticationFailed) => {
        return Err(MediaError::AuthenticationFailed);
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(ParseUploadError) => Err(MediaError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(ParseUploadError::MaximumUploadSizeReached) => {
        Err(MediaError::MaximumUploadSizeReached)
      },Err(ParseUploadError::TimedOut) => {
        Err(MediaError::TimedOut)
      },Err(ParseUploadError::AuthenticationFailed) => {
        Err(MediaError::AuthenticationFailed)
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||ParseUploadError => return MediaError) => {
    match$expr {
      $($patterns =>  $results,)+ParseUploadError::MaximumUploadSizeReached => {
        return MediaError::MaximumUploadSizeReached;
      },ParseUploadError::TimedOut => {
        return MediaError::TimedOut;
      },ParseUploadError::AuthenticationFailed => {
        return MediaError::AuthenticationFailed;
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||ParseUploadError => MediaError) => {
    match$expr {
      $($patterns =>  $results,)+ParseUploadError::MaximumUploadSizeReached => {
        MediaError::MaximumUploadSizeReached
      },ParseUploadError::TimedOut => {
        MediaError::TimedOut
      },ParseUploadError::AuthenticationFailed => {
        MediaError::AuthenticationFailed
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(ParseUploadError) => return Err(ParseUploadError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(ParseUploadError::MaximumUploadSizeReached) => {
        return Err(ParseUploadError::MaximumUploadSizeReached);
      },Err(ParseUploadError::TimedOut) => {
        return Err(ParseUploadError::TimedOut);
      },Err(ParseUploadError::AuthenticationFailed) => {
        return Err(ParseUploadError::AuthenticationFailed);
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||Err(ParseUploadError) => Err(ParseUploadError)) => {
    match$expr {
      $($patterns =>  $results,)+Err(ParseUploadError::MaximumUploadSizeReached) => {
        Err(ParseUploadError::MaximumUploadSizeReached)
      },Err(ParseUploadError::TimedOut) => {
        Err(ParseUploadError::TimedOut)
      },Err(ParseUploadError::AuthenticationFailed) => {
        Err(ParseUploadError::AuthenticationFailed)
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||ParseUploadError => return ParseUploadError) => {
    match$expr {
      $($patterns =>  $results,)+ParseUploadError::MaximumUploadSizeReached => {
        return ParseUploadError::MaximumUploadSizeReached;
      },ParseUploadError::TimedOut => {
        return ParseUploadError::TimedOut;
      },ParseUploadError::AuthenticationFailed => {
        return ParseUploadError::AuthenticationFailed;
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }||ParseUploadError => ParseUploadError) => {
    match$expr {
      $($patterns =>  $results,)+ParseUploadError::MaximumUploadSizeReached => {
        ParseUploadError::MaximumUploadSizeReached
      },ParseUploadError::TimedOut => {
        ParseUploadError::TimedOut
      },ParseUploadError::AuthenticationFailed => {
        ParseUploadError::AuthenticationFailed
      },
    }
  };
  ($expr:expr => {
    $($patterns:pat =>  $results:expr), +
  }) => {
    match$expr {
      $($patterns =>  $results,)+
    }
  };
  ($($other:tt)*) => {
    compile_error!(r#"
No patterns matched. 
Possible reasons:
    1. There are no intersections between the sets.
    2. The last arm of of "$arms" has a trailing comma.
    3. The pattern is incorrect.
`coerce` is expected to follow the pattern:

coerce!($VAR => { <$arms>+ }< || one_of< <$FROM => $TO>, <$FROM => return $TO>, <Err($FROM) => Err($TO)>, <Err($FROM) => return Err($TO)> >

?)

"#)
  };
}
pub(crate)use coerce;

which is also equivalent to writing:

error_set! {
    MediaError = {
        IoError(std::io::Error),
        MissingBookDescription,
        MissingName,
        NoContents,
        InvalidUrl,
        MaximumUploadSizeReached,
        TimedOut,
        AuthenticationFailed,
    };
    BookParsingError = {
        MissingBookDescription,
        CouldNotReadBook(std::io::Error),
        MissingName,
        NoContents,
    };
    BookSectionParsingError = {
        MissingName,
        NoContents,
    };
    DownloadError = {
        InvalidUrl,
        CouldNotSaveBook(std::io::Error),
    };
    ParseUploadError = {
        MaximumUploadSizeReached,
        TimedOut,
        AuthenticationFailed,
    };
}

Error enums and error variants can also accept doc comments and attributes like #[derive(...)].

error_set! Examples

fn main() {
    let book_section_parsing_error = BookSectionParsingError::MissingName;
    let book_parsing_error: BookParsingError = book_section_parsing_error.coerce(); // `.coerce()` == `.into()`
    assert!(matches!(book_parsing_error, BookParsingError::MissingName));
    let media_error: MediaError = book_parsing_error.coerce(); // `.coerce()` == `.into()`
    assert!(matches!(media_error, MediaError::MissingName));

    let io_error =std::io::Error::new(std::io::ErrorKind::OutOfMemory, "oops out of memory");
    let result_download_error: Result<(), DownloadError> = Err(io_error).coerce(); // `.coerce()` == `.map_err(Into::into)`
    let result_media_error: Result<(), MediaError> = result_download_error.coerce(); // `.coerce()` == `.map_err(Into::into)`
    assert!(matches!(result_media_error, Err(MediaError::IoError(_))));
}

error_set::error_set! {
    MediaError = {
        IoError(std::io::Error)
    } || BookParsingError || DownloadError || UploadError;
    BookParsingError = {
        MissingContent,
        BookAccess(std::io::Error),
    };
    DownloadError = {
        InvalidUrl,
        CouldNotSaveBook(std::io::Error),
    };
    UploadError = {
        MaximumUploadSizeReached,
        TimedOut,
        AuthenticationFailed,
    };
}

fn parse_book(file_path: &str) -> Result<String, BookParsingError> {
    let mut file = File::open(file_path).coerce::<BookParsingError>()?;
    let mut content = String::new();
    file.read_to_string(&mut content).coerce::<BookParsingError>()?;
    if content.is_empty() {
        Err(BookParsingError::MissingContent)
    } else {
        Ok(content)
    }
}

fn download_book(url: &str, save_path: &str) -> Result<(), DownloadError> {
    if url.is_empty() {
        Err(DownloadError::InvalidUrl)
    } else {
        let simulated_book_content = "This is a downloaded book content.";
        let mut file = File::create(save_path).coerce::<DownloadError>()?;
        file.write_all(simulated_book_content.as_bytes()).coerce::<DownloadError>()?;
        Ok(())
    }
}

fn upload_content(content: &str) -> Result<(), UploadError> {
    let auth = true;
    if !auth { // Simulate auth
        return Err(UploadError::AuthenticationFailed);
    }
    let time_out = false;
    if !time_out { // Simulate timeout uploading
        return Err(UploadError::TimedOut);
    }
    if content.len() > 1024 { // Simulate an upload size limit
        Err(UploadError::MaximumUploadSizeReached)
    } else {
        println!("Book uploaded successfully.");
        Ok(())
    }
}

fn process_book(download_path: &str, download_url: &str) -> Result<String, MediaError> {
    download_book(download_url, download_path).coerce::<MediaError>()?;
    let content = parse_book(download_path).coerce::<MediaError>()?;
    const MAX_RETRIES: u8  = 3;
    let mut current_retries = 0;
    match upload_content(&content) {
        Err(UploadError::TimedOut) => {
            while current_retries < MAX_RETRIES {
                current_retries += 1;
                if let Ok(_) = upload_content(&content) {
                    break;
                }
            }
        }
        Err(e) => return Err(e.coerce()),
        _ => (),
    }
    fs::remove_file(download_path).coerce::<MediaError>()?;
    Ok(content)
}

fn main() {
    match process_book("downloaded_book.txt", "http://example.com/book") {
        Ok(content) => println!("Book processed successfully: {}", content),
        Err(e) => eprintln!("An error occurred: {:?}", e),
    }
}

The coerce! Macro

The coerce! macro handles coercing between intersecting sets (sets where some of the error types are in common), which allows you to care about only the parts that matter to you, such as the disjointedness. e.g. given:

error_set! {
   SetX = {
       X
   } || Common;
   SetY = {
       Y
   } || Common;
   Common = {
       A,
       B,
       C,
       D,
       E,
       F,
       G,
       H,
   };
}

rather than writting:

fn setx_result_to_sety_result() -> Result<(), SetY> {
   let _ok = match setx_result() {
       Ok(ok) => ok,
       Err(SetX::X) => {} // handle disjointedness
       Err(SetX::A) => {
           return Err(SetY::A);
       }
       Err(SetX::B) => {
           return Err(SetY::B);
       }
       Err(SetX::C) => {
           return Err(SetY::C);
       }
       Err(SetX::D) => {
           return Err(SetY::D);
       }
       Err(SetX::E) => {
           return Err(SetY::E);
       }
       Err(SetX::F) => {
           return Err(SetY::F);
       }
       Err(SetX::G) => {
           return Err(SetY::G);
       }
       Err(SetX::H) => {
           return Err(SetY::H);
       }
   };
   Ok(())
}

you can write this:

fn setx_result_to_sety_result() -> Result<(),SetY> {
   let _ok = coerce!(setx_result() => {
       Ok(ok) => ok,
       Err(SetX::X) => {} // handle disjointedness
   } || Err(SetX) => return Err(SetY));
   Ok(())
}

The coerce! macro is a flat fast (no tt muncher 🦫) declarative macro created by the error_set! macro for the set. It compiles to the previous match statement above. With it, you can concisely handle specific variants of errors as they bubble up the call stack and propagate the rest.