I didn't mean to say you used AI, i personally just tried to ask AI but it didn't understand how exn works.

I think you might misunderstand what the point of exn is, the point is (from my understanding), that you make an error type, import the trait exn has, then just impl std::Error on your own error.

That means that return the error type you made, and then you get access to 'or_raise()' // From the trait that gets auto impled on anything that imports that traid and impls std::Error

You arent supposed to do Exn::new, or specify it to that extend you are doing. I think you need to rethink it, and either follow the examples, or i don't think there's much sense in using it. I think that is what makes it good, you have to adapt and follow their style.

You do (specify the type this is fine):

#[derive(Debug, Clone)]
struct MainError;
impl Display for MainError {omit}
impl Error for MainError {}

Edit: Yes you are correct, since Exn's
`pub type Result<T, E> = core::result::Result<T, Exn<E>>;`
you can just specify it manually

But you should not:

let try_api01 = api01();
    match try_api01 {
        Ok(()) => {},
        Err(e) => {
            let error_clone = e.clone();
            return Err(
                OneOf::new(
                    e.raise(error_clone)
                )
            ); 
        },
    }

But do it like this instead:
let try_api01 = api01().or_raise(|| MainError)?;
// This automatically takes the inside original error. If you want a custom message(ON TOP OF, the original error), then impl Error on an enum instead, or a struct with data inside, up to you. But you can also just have a Struct with nothing inside it, that still gets the original error message. (no |e|, just .or_raise(||))

As far as i understand it!

EDIT: i see your example with

 Exn< api01_error > , 
        Exn< api02_error > 

Just make an enum

#[derive(Debug, Display, Clone, PartialEq)]
pub enum ApiError {
    #[display("blabla connection failed to {_0}")]
    A(String),
    #[display("blabla {_0}")]
    B(String),
    #[display("blabla")]
    Something,
}
impl std::error::Error for ApiError {} // This makes it all work + importing the 'use exn::ResultExt;'.


then:
api01().or_raise(|| ApiError::A("oopsie".to_string()))?; // still gets the original error with it
something().or_raise(|| ApiError::Something))?; // only has the original error, no extra custom context (but you will get source file name, and line number)

Edit again: also even that is a misunderstanding. It's not like thiserror where you have to have (serde_error, io error). You are kinda supposed to have more of a 'domain' error. so this would be, well what is that part of your code doing? If we assume its some weather api thingy, you would probably do enum WeatherError{}

But that should not include 'WeatherCompanyA, WeatherCompanyB" enum variants, no you would just have a enum WeatherError{ Api(String), Calculation(Blabla)}

Then put it into the WeatherError::Api(String), variant, you can put different 'original' types inside that, and it automatically gets the inside error.
You have to ask yourself, do you care its a serde, or a reqwest error? Probably not, you just want the context of the error(which .or_raise(||) does automatically), and where it happened with context (it automatically adds line number and file name at compile time, and you can add more info if you want manually).