use std::ptr;

use std::ptr::{self, NonNull};

            object_downcast: object_downcast::<E>,

            object_downcast: object_downcast::<M>,

            object_downcast: object_downcast::<M>,

            object_downcast: object_downcast::<ContextError<C, E>>,

            object_downcast: object_downcast::<ContextError<C, Error>>,

        if self.is::<E>() {

        let target = TypeId::of::<E>();
        unsafe {
            let addr = match (self.inner.vtable.object_downcast)(&self.inner, target) {
                Some(addr) => addr,
                None => return Err(self),
            };

            unsafe {
                let error = ptr::read(
                    outer.inner.error() as *const (dyn StdError + Send + Sync) as *const E
                );
                let inner = ptr::read(&outer.inner);
                let erased = ManuallyDrop::into_inner(inner);
                (erased.vtable.object_drop_front)(erased);
                Ok(error)
            }
        } else {
            Err(self)

            let error = ptr::read(addr.cast::<E>().as_ptr());
            let inner = ptr::read(&outer.inner);
            let erased = ManuallyDrop::into_inner(inner);
            (erased.vtable.object_drop_front)(erased);
            Ok(error)

        if self.is::<E>() {
            Some(unsafe {
                &*(self.inner.error() as *const (dyn StdError + Send + Sync) as *const E)
            })
        } else {
            None

        let target = TypeId::of::<E>();
        unsafe {
            let addr = (self.inner.vtable.object_downcast)(&self.inner, target)?;
            Some(&*addr.cast::<E>().as_ptr())

        if self.is::<E>() {
            Some(unsafe {
                &mut *(self.inner.error_mut() as *mut (dyn StdError + Send + Sync) as *mut E)
            })
        } else {
            None

        let target = TypeId::of::<E>();
        unsafe {
            let addr = (self.inner.vtable.object_downcast)(&self.inner, target)?;
            Some(&mut *addr.cast::<E>().as_ptr())

    object_downcast: unsafe fn(&ErrorImpl<()>, TypeId) -> Option<NonNull<()>>,

unsafe fn object_is<T>(target: TypeId) -> bool

unsafe fn object_is<E>(target: TypeId) -> bool
where
    E: 'static,
{
    TypeId::of::<E>() == target
}
unsafe fn object_downcast<E>(e: &ErrorImpl<()>, target: TypeId) -> Option<NonNull<()>>

    T: 'static,

    E: 'static,

    TypeId::of::<T>() == target

    if TypeId::of::<E>() == target {
        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<E>;
        let addr = &(*unerased)._error as *const E as *mut ();
        Some(NonNull::new_unchecked(addr))
    } else {
        None
    }