Struct spin::lazy::Lazy

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

A value which is initialized on the first access.

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

Examples

use std::collections::HashMap;
use spin::Lazy;

static HASHMAP: Lazy<HashMap<i32, String>> = Lazy::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> Lazy<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> Lazy<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::Lazy;

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

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

Trait Implementations

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

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

Formats the value using the given formatter.

impl<T: Default, R> Default for Lazy<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 Lazy<T, F, R>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

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

where Once<T>: Sync,