Struct serde::lib::core::sync::LazyLock

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

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.

use std::sync::LazyLock;

// n.b. static items do not call [`Drop`] on program termination, so this won't be deallocated.
// this is fine, as the OS can deallocate the terminated program faster than we can free memory
// but tools like valgrind might report "memory leaks" as it isn't obvious this is intentional.
static DEEP_THOUGHT: LazyLock<String> = LazyLock::new(|| {
    // M3 Ultra takes about 16 million years in --release config
    another_crate::great_question()
});

// The `String` is built, stored in the `LazyLock`, and returned as `&String`.
let _ = &*DEEP_THOUGHT;
// The `String` is retrieved from the `LazyLock` and returned as `&String`.
let _ = &*DEEP_THOUGHT;

Initialize fields with LazyLock.

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

data: UnsafeCell<Data<T, F>>

Implementations

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

where F: FnOnce() -> T,

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

Creates a new lazy value with the given initializing function.

Examples

use std::sync::LazyLock;

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

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

assert_eq!(&*lazy, "HELLO, WORLD!");

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_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

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

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,