Struct scrypto_test::prelude::radix_engine_common::prelude::rust::sync::LazyLock

pub struct LazyLock<T, F = fn() -> T> {
    once: Once,
    data: UnsafeCell<Data<T, F>>,
}

🔬This is a nightly-only experimental API. (lazy_cell)

A value which is initialized on the first access.

This type is a thread-safe LazyCell, and can be used in statics. Since initialization may be called from multiple threads, any dereferencing call will block the calling thread if another initialization routine is currently running.

Examples

Initialize static variables with LazyLock.

#![feature(lazy_cell)]

use std::collections::HashMap;

use std::sync::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")
}

Initialize fields with LazyLock.

#![feature(lazy_cell)]

use std::sync::LazyLock;

#[derive(Debug)]
struct UseCellLock {
    number: LazyLock<u32>,
}
fn main() {
    let lock: LazyLock<u32> = LazyLock::new(|| 0u32);

    let data = UseCellLock { number: lock };
    println!("{}", *data.number);
}

Fields

once: Once

🔬This is a nightly-only experimental API. (lazy_cell)

data: UnsafeCell<Data<T, F>>

🔬This is a nightly-only experimental API. (lazy_cell)

Implementations

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

where F: FnOnce() -> T,

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

🔬This is a nightly-only experimental API. (lazy_cell)

Creates a new lazy value with the given initializing function.

pub fn into_inner(this: LazyLock<T, F>) -> Result<T, F>

🔬This is a nightly-only experimental API. (lazy_cell_consume)

Consumes this LazyLock returning the stored value.

Returns Ok(value) if Lazy is initialized and Err(f) otherwise.

Examples

#![feature(lazy_cell)]
#![feature(lazy_cell_consume)]

use std::sync::LazyLock;

let hello = "Hello, World!".to_string();

let lazy = LazyLock::new(|| hello.to_uppercase());

assert_eq!(&*lazy, "HELLO, WORLD!");
assert_eq!(LazyLock::into_inner(lazy).ok(), Some("HELLO, WORLD!".to_string()));

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

🔬This is a nightly-only experimental API. (lazy_cell)

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

This method will block the calling thread if another initialization routine is currently running.

Examples

#![feature(lazy_cell)]

use std::sync::LazyLock;

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

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

Trait Implementations

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

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for LazyLock<T>

where T: Default,

fn default() -> LazyLock<T>

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

impl<T, F> Deref for LazyLock<T, F>

where F: FnOnce() -> T,

fn deref(&self) -> &T

Dereferences the value.

This method will block the calling thread if another initialization routine is currently running.

type Target = T

The resulting type after dereferencing.

impl<T, F> Drop for LazyLock<T, F>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, F> RefUnwindSafe for LazyLock<T, F>

where T: RefUnwindSafe + UnwindSafe, F: UnwindSafe,

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

where T: Sync + Send, F: Send,

impl<T, F> UnwindSafe for LazyLock<T, F>

where T: UnwindSafe, F: UnwindSafe,