main.rs

#[macro_use]
extern crate error_chain;
#[macro_use]
extern crate quick_error;

quick_error! {
    #[derive(Debug)]
    pub enum ForeignA {
        Foo {
            description("foo")
            display("foo")
        }
    }
}

quick_error! {
    #[derive(Debug)]
    pub enum ForeignB {
        Foo {
            description("foo")
            display("foo")
        }
    }
}

error_chain! {
    types {
        Error, ErrorKind, ChainErr, Result;
    }

    links {}

    foreign_links {
        ForeignA, A, "a";
        ForeignB, B, "b";
    }

    errors {}
}

fn main() {
    let e: Error = Error::from(ForeignA::Foo);

    // Let's assume we don't know the cause of e
    match *e.kind() {
        ErrorKind::Msg(_) => println!("it's a Msg"),
        ErrorKind::A => {
            if let Error(_, (Some(ref cause), _)) = e {
                match cause.downcast_ref::<ForeignA>() {
                    Some(b) => {
                        match *b {
                            ForeignA::Foo => println!("it's a ForeignA::Foo")
                        }
                    },
                    None => unreachable!()
                }
            } else {
                unreachable!()
            }
        }
        ErrorKind::B => {
            if let Error(_, (Some(ref cause), _)) = e {
                match cause.downcast_ref::<ForeignB>() {
                    Some(b) => {
                        match *b {
                            ForeignB::Foo => println!("it's a ForeignB::Foo")
                        }
                    },
                    None => unreachable!()
                }
            } else {
                unreachable!()
            }
        }
    }
}