Struct std::sync::LazyLock

1.80.0 · source ·
pub struct LazyLock<T, F = fn() -> T> { /* private fields */ }
Expand description

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::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")
}
Run

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);
}
Run

Implementations§

source§

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

1.80.0 (const: 1.80.0) · source

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!");
Run
source

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

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

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()));
Run
1.80.0 · source

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);
Run

Trait Implementations§

1.80.0 · source§

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

source§

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

Formats the value using the given formatter. Read more
1.80.0 · source§

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

source§

fn default() -> LazyLock<T>

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

1.80.0 · source§

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

source§

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.
1.80.0 · source§

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

source§

fn drop(&mut self)

Executes the destructor for this type. Read more
1.80.0 · source§

impl<T: RefUnwindSafe + UnwindSafe, F: UnwindSafe> RefUnwindSafe for LazyLock<T, F>

1.80.0 · source§

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

1.80.0 · source§

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

Auto Trait Implementations§

§

impl<T, F = fn() -> T> !Freeze for LazyLock<T, F>

§

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

§

impl<T, F> Unpin for LazyLock<T, F>
where T: Unpin, F: Unpin,

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.