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 be moved onto bocking threads that 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 Future being polled. This crate provides some safe abstractions such as AsyncLocal::withasync as well as the unsafe building blocks and safety considerations for creating narrowly-tailored safe abstractions capable of using stable references to thread locals soundly in an async context and across await points.
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.