use crate::Exception;

use crate::Error;

impl AsError for Exception {

impl AsError for Error {

use crate::Exception;

use crate::Error;

    fn context<C: Display + Send + Sync + 'static>(self, context: C) -> Result<T, Exception>;

    fn context<C: Display + Send + Sync + 'static>(self, context: C) -> Result<T, Error>;

    fn with_context<C, F>(self, f: F) -> Result<T, Exception>

    fn with_context<C, F>(self, f: F) -> Result<T, Error>

    fn context<C: Display + Send + Sync + 'static>(self, context: C) -> Result<T, Exception> {
        self.map_err(|error| Exception::from(ContextError { error, context }))

    fn context<C: Display + Send + Sync + 'static>(self, context: C) -> Result<T, Error> {
        self.map_err(|error| Error::from(ContextError { error, context }))

    fn with_context<C, F>(self, f: F) -> Result<T, Exception>

    fn with_context<C, F>(self, f: F) -> Result<T, Error>

            Exception::from(ContextError {

            Error::from(ContextError {

impl<T> Context<T, Exception> for Result<T, Exception> {
    fn context<C: Display + Send + Sync + 'static>(self, context: C) -> Result<T, Exception> {
        self.map_err(|error| Exception::from(ContextError { error, context }))

impl<T> Context<T, Error> for Result<T, Error> {
    fn context<C: Display + Send + Sync + 'static>(self, context: C) -> Result<T, Error> {
        self.map_err(|error| Error::from(ContextError { error, context }))

    fn with_context<C, F>(self, f: F) -> Result<T, Exception>

    fn with_context<C, F>(self, f: F) -> Result<T, Error>

        F: FnOnce(&Exception) -> C,

        F: FnOnce(&Error) -> C,

            Exception::from(ContextError {

            Error::from(ContextError {

impl<C: Display> StdError for ContextError<Exception, C> {

impl<C: Display> StdError for ContextError<Error, C> {

/// The `Exception type, a wrapper around a dynamic error type.

/// The `Error` type, a wrapper around a dynamic error type.

/// `Exception` functions a lot like `Box<dyn Error>`, with these differences:

/// `Error` functions a lot like `Box<dyn std::error::Error>`, with these differences:

/// - `Exception` requires that the error is `Send`, `Sync`, and `'static`
/// - `Exception` guarantees that a backtrace will exist, even if the error type

/// - `Error` requires that the error is `Send`, `Sync`, and `'static`
/// - `Error` guarantees that a backtrace will exist, even if the error type

/// - `Exception` is represented as a narrow pointer - exactly one word in size,

/// - `Error` is represented as a narrow pointer - exactly one word in size,

pub struct Exception {

pub struct Error {

impl Exception {

impl Error {

    /// The error type must be threadsafe and `'static`, so that the `Exception` will be as well.

    /// The error type must be threadsafe and `'static`, so that the `Error` will be as well.

    pub fn new<E>(error: E) -> Exception

    pub fn new<E>(error: E) -> Error

        Exception::construct(error, TypeId::of::<E>())

        Error::construct(error, TypeId::of::<E>())

    pub fn new_adhoc<M>(message: M) -> Exception

    pub fn new_adhoc<M>(message: M) -> Error

        Exception::construct(MessageError(message), TypeId::of::<M>())

        Error::construct(MessageError(message), TypeId::of::<M>())

    fn construct<E>(error: E, type_id: TypeId) -> Exception

    fn construct<E>(error: E, type_id: TypeId) -> Error

            Exception {

            Error {

    /// Get the backtrace for this Exception.

    /// Get the backtrace for this Error.

    /// An iterator of errors contained by this Exception.

    /// An iterator of errors contained by this Error.

    pub fn downcast<E: Display + Debug + Send + Sync + 'static>(self) -> Result<E, Exception> {

    pub fn downcast<E: Display + Debug + Send + Sync + 'static>(self) -> Result<E, Error> {

impl<E: StdError + Send + Sync + 'static> From<E> for Exception {
    fn from(error: E) -> Exception {
        Exception::new(error)

impl<E: StdError + Send + Sync + 'static> From<E> for Error {
    fn from(error: E) -> Error {
        Error::new(error)

impl Deref for Exception {

impl Deref for Error {

impl DerefMut for Exception {

impl DerefMut for Error {

impl Debug for Exception {

impl Debug for Error {

impl Display for Exception {

impl Display for Error {

unsafe impl Send for Exception {}
unsafe impl Sync for Exception {}

unsafe impl Send for Error {}
unsafe impl Sync for Error {}

impl Drop for Exception {

impl Drop for Error {

/// Iterator of errors in an `Exception`.

/// Iterator of errors in an `Error`.

        assert_eq!(mem::size_of::<Exception>(), mem::size_of::<usize>());

        assert_eq!(mem::size_of::<Error>(), mem::size_of::<usize>());

        Exception: Unpin + Send + Sync + 'static,

        Error: Unpin + Send + Sync + 'static,

        drop(Exception::from(HasDrop(Box::new(has_dropped.clone()))));

        drop(Error::from(HasDrop(Box::new(has_dropped.clone()))));

pub use crate::error::{Errors, Exception};

pub use crate::error::{Error, Errors};

/// This evaluates to an `Exception`. It can take either just a string, or a format string with

/// This evaluates to an `Error`. It can take either just a string, or a format string with

    ($e:expr)   => { $crate::Exception::new_adhoc($e) };
    ($($arg:tt)*) => { $crate::Exception::new_adhoc(format!($($arg)*)) };

    ($e:expr)   => { $crate::Error::new_adhoc($e) };
    ($($arg:tt)*) => { $crate::Error::new_adhoc(format!($($arg)*)) };