Is non-recursive downcasting supported? about anyhow HOT 2 CLOSED

use anyhow::{anyhow, Error};
use std::fmt::{self, Debug, Display};

pub struct Internal(Error);

impl std::error::Error for Internal {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        self.0.source()
    }
}

impl Debug for Internal {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        Debug::fmt(&self.0, f)
    }
}

impl Display for Internal {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        Display::fmt(&self.0, f)
    }
}

fn main() {
    let e0 = anyhow!("e0");
    let e1 = e0.context("e1");
    let e2 = e1.context("e2");
    let e2_internal = anyhow!(Internal(e2));
    let e3 = e2_internal.context("e3");
    let e4 = e3.context("e4");

    println!("recursive downcast: {}", e4.downcast_ref::<Internal>().is_some());
    println!("nonrecursive downcast: {}", (*e4).downcast_ref::<Internal>().is_some());

    for e in e4.chain() {
        println!("{} {}", e, e.downcast_ref::<Internal>().is_some());
    }
}