Struct Lazy 

pub struct Lazy<T> { /* private fields */ }

Lazy is a thread-safe, lazily-initialized global variable.

Unlike other async once-cell implementations, accessing the value of a Lazy instance is synchronous and done on deref.

This is done by offloading the async initialization to a blocking thread during the first access, and then using the initialized value for all subsequent accesses.

It uses std::sync::OnceLock internally to ensure that the value is only initialized once.

Implementations

impl<T: Send + Sync + 'static> Lazy<T>

pub const fn lazy() -> Self

Create a new Lazy instance.

This internally calls std::sync::OnceLock::new() under the hood.

pub const fn new<F, G, E>(constructor: F) -> Self

where F: Fn() -> G + Copy, G: Future<Output = Result<T, E>> + Send + 'static, E: Into<CapturedError>,

pub fn set(&self, pool: T) -> Result<(), CapturedError>

Set the value of the Lazy instance.

This should only be called once during the server setup phase, typically inside dioxus::serve. Future calls to this method will return an error containing the provided value.

pub fn try_set(&self, pool: T) -> Result<(), T>

pub fn initialize(&self) -> Result<(), CapturedError>

Initialize the value of the Lazy instance if it hasn’t been initialized yet.

pub fn get(&self) -> &T

Get a reference to the value of the Lazy instance. This will block the current thread if the value is not yet initialized.

Trait Implementations

impl<T: Debug + Send + Sync + 'static> Debug for Lazy<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Send + Sync + 'static> Default for Lazy<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Send + Sync + 'static> Deref for Lazy<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.