Struct LazyLock

pub struct LazyLock<T, F = fn() -> T> { /* private fields */ }

Wrapper for std::sync::LazyLock

This wrapper participates in cycle detection like all other primitives in this crate. It should only be possible to encounter cycles when acquiring mutexes in the initialisation function.

Examples

use tracing_mutex::stdsync::tracing::LazyLock;

static LOCK: LazyLock<i32> = LazyLock::new(|| {
    println!("Hello, world!");
    42
});

// This should print "Hello, world!"
println!("{}", *LOCK);
// This should not.
println!("{}", *LOCK);

Implementations

impl<T, F: FnOnce() -> T> LazyLock<T, F>

pub const fn new(f: F) -> LazyLock<T, F>

Creates a new lazy value with the given initializing function.

pub fn force(this: &LazyLock<T, F>) -> &T

Force this lazy lock to be evaluated.

This is equivalent to dereferencing, but is more explicit.

Trait Implementations

impl<T: Debug, F> Debug for LazyLock<T, F>

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

Formats the value using the given formatter.

impl<T: Default> Default for LazyLock<T>

fn default() -> Self

Return a LazyLock that is initialized through Default.

impl<T, F: FnOnce() -> T> Deref for LazyLock<T, F>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.