Traditionally the downside of thread-locals has been that usage is constrained to the LocalKey::with closure with no lifetime escapement thus making usage within an async context limited to calls between await points with no guarantee of reference stability. This makes a lot of sense for a number of reasons: there is no clear way to express the lifetime of a thread, the lifetime's of threads are never equivalent, extending the lifetime to 'static can result in dangling pointers during shutdown should references outlive the referenced thread local, and because during runtime shutdown references to thread locals from other runtime threads may dangle on drop. Despite all these constraints however, there yet exists ways to make it possible to hold references to thread locals beyond the standard lifetime of thread locals and across await points by creating safe abstractions that logically constrain usage to exclusively be within an async context by tying to non-'static lifetimes such as 'asynctrait or that of a pinned Future being polled or dropped. This crate provides some safe abstractions such as AsyncLocal::withasync as well as the unsafe pointer types and safety considerations for creating narrowly-tailored safe abstractions for using pointers to thread locals soundly in an async context and across await points as well as a solution for guaranteeing that the drop impl of pinned futures will never have dangling references during the runtime shutdown sequence by forcing all tasks to be dropped before any referenced thread local can be dropped.
This crate conditionally makes use of the nightly only feature typealiasimpltrait to allow AsyncLocal::withasync to be unboxed. To compile on stable the boxed feature flag can be be used to downgrade async_t::async_trait to async_trait::async_trait.