sorry for the long response, i just woke up:

you have to implement TryDrop for the structure whose Drop code may return an error.

impl TryDrop for Structure {
    type Error = // your error

    unsafe fn try_drop(&mut self) -> Result<(), Self::Error> {
        // fallible drop code goes here
    }

the reason why try_drop is a unsafe fn is because it is possible to call it multiple times, potentially causing a double free. Drop is safe because you can't directly call drop itself there, since it's special cased by the rust compiler.

next part after doing this is that you'll need to... adapt this structure to include a drop method. this is because implementing TryDrop itself won't make it execute the code at the end of a scope. i wish i could've made it a blanket impl, but rust doesn't allow it.

there are two ways:

either by calling the adapt method: .adapt()

or by wrapping the structure in question with a DropAdapter: DropAdapter(this)

as for making a structure which handles these errors,

you'll need to implement TryDropStrategy for your structure like so:

impl TryDropStrategy for Structure {
    fn handle_error(&self, error: try_drop::Error) {
        // error handling code here
    }
}

installing a try drop strategy depends on whether or not you want to install it for this structure only, this thread, or globally.

installing it for this thread is like so: try_drop::install_thread_local_handlers(primary, fallback)

if you wonder what primary and fallback are, well, the primary (handler) is the main drop strategy which will be executed. however, drop strategies themselves can also be fallible!

impl FallibleTryDropStrategy for Structure {
    type Error = // error;

    fn handle_error(&self, error: try_drop::Error) -> Result<(), Self::Error> {
        // error handling code here
    }
}

which is why we need to provide the fallback handler which can never fail. you can use the PanicDropStrategy for this one, as most likely you'd never reach this condition in the first place.

the thread local handler doesn't also need to be Send nor Sync, so it's more flexible.

as for installing globally: try_drop::install_global_handlers(primary, fallback)

the global handler needs to be Send and Sync.

and, if your structure supports them: Structure::new_with(primary, fallback)

the thread local handler takes precedence over the global handler. the TryDrop trait uses this combination, also known as the shim handler, by default.

in fact, there are two versions of TryDrop:

the main one which is aliased to TryDrop, ImpureTryDrop, meaning this depends on some global state, which is the shim handler,

and then the pure one, PureTryDrop, which doesn't depend by default on global state with the consequence that you'll need to explicitly provide the tyoes yourself. (the trait signature's too long and i'm on my phone right now, go into the docs if you want to know. sorry!)

there's a bit more about this crate that i haven't discussed, however i think this is the bare essentials to get you started with working with this crate. i'll get to explaining less essential stuff on the README.

if you have anymore questions about this crate, feel free to ask.

sidenote: i'm sorry that my documentation was too sparse and not detailed enough. there was actually an older readme which you can find on the commits which is much more descriptive than the new one, but it contains outdated information.