once_cell

I've used once_cell extensively for lazy static initialization and it's become my go-to for anything that needs single-assignment semantics. The OnceCell and Lazy types are rock-solid in production with zero runtime overhead after initialization. Unlike lazy_static, there's no macro magic obscuring what's happening, just straightforward APIs that compile down to excellent machine code.

The sync and unsync modules make thread-safety explicit, which prevents accidental performance penalties. I particularly appreciate that get_or_init and get_or_try_init return references directly without Box overhead. Memory usage is minimal - just the stored value plus a single atomic flag for sync types. The blocking behavior during concurrent initialization is well-documented and predictable under load.

Error handling with get_or_try_init is clean, though you need to understand that failed initializations don't poison the cell - subsequent calls will retry. This is actually the right default for most production scenarios where transient errors shouldn't permanently break your application state.

I've used once_cell extensively for lazy statics and one-time initialization across multiple production services. From a security perspective, it's a model dependency: zero transitive dependencies, pure Rust with no unsafe FFI exposure, and minimal attack surface. The API is straightforward—OnceCell for single-assignment and Lazy for lazy evaluation—with no hidden complexity or surprises.

The library handles initialization errors cleanly without exposing internal state. Poisoning behavior is explicit and well-documented, preventing race conditions in multi-threaded contexts. Input validation is your responsibility (as it should be), but once_cell never silently swallows panics or creates undefined behavior. The sync and unsync variants make thread-safety guarantees clear at compile time.

CVE response has been solid—the maintainer addresses issues promptly when they arise. The codebase is small enough to audit yourself in an afternoon. Now that std::sync::LazyLock and std::cell::LazyCell are stabilizing in newer Rust versions, once_cell serves as either a polyfill or direct replacement depending on your MSRV requirements.

once_cell has become my go-to for lazy static initialization in Rust. The API is incredibly intuitive - `Lazy::new()` for thread-safe globals and `OnceCell` for single-assignment cells work exactly as you'd expect. The `get_or_init()` pattern feels natural, and the trait-based design means you can easily swap between sync and unsync variants depending on your needs.

Documentation is excellent with clear examples for common patterns like lazy regex compilation, config initialization, and caching. Error messages are straightforward when you hit issues like attempting multiple initializations. The crate integrates seamlessly with IDE tooling - autocomplete suggestions are spot-on, and type inference works without fighting the compiler.

Migration between versions has been painless in my experience. The API is stable and well-thought-out. While parts are being standardized into std::sync::OnceLock in newer Rust versions, once_cell remains the more feature-complete option with better ergonomics for complex initialization patterns.