Struct LazyLock 

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

A value which is initialized on the first access.

This type is a thread-safe LazyLock, and can be used in statics.

Examples

use std::collections::HashMap;
use spin::LazyLock;

static HASHMAP: LazyLock<HashMap<i32, String>> = LazyLock::new(|| {
    println!("initializing");
    let mut m = HashMap::new();
    m.insert(13, "Spica".to_string());
    m.insert(74, "Hoyten".to_string());
    m
});

fn main() {
    println!("ready");
    std::thread::spawn(|| {
        println!("{:?}", HASHMAP.get(&13));
    }).join().unwrap();
    println!("{:?}", HASHMAP.get(&74));

    // Prints:
    //   ready
    //   initializing
    //   Some("Spica")
    //   Some("Hoyten")
}

Implementations

impl<T, F, R> LazyLock<T, F, R>

pub const fn new(f: F) -> Self

Creates a new lazy value with the given initializing function.

pub fn as_mut_ptr(&self) -> *mut T

Retrieves a mutable pointer to the inner data.

This is especially useful when interfacing with low level code or FFI where the caller explicitly knows that it has exclusive access to the inner data. Note that reading from this pointer is UB until initialized or directly written to.

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

pub fn force(this: &Self) -> &T

Forces the evaluation of this lazy value and returns a reference to result. This is equivalent to the Deref impl, but is explicit.

Examples

use spin::LazyLock;

let lazy = LazyLock::new(|| 92);

assert_eq!(LazyLock::force(&lazy), &92);
assert_eq!(&*lazy, &92);

Trait Implementations

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

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

Formats the value using the given formatter.

impl<T: Default, R> Default for LazyLock<T, fn() -> T, R>

fn default() -> Self

Creates a new lazy value using Default as the initializing function.

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

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T, F: Send> Sync for LazyLock<T, F>

where Once<T>: Sync,