pub struct LazyLock<T, F = fn() -> T> {
once: Once,
data: UnsafeCell<Data<T, F>>,
}
lazy_cell
)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
.
#![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
lazy_cell
)data: UnsafeCell<Data<T, F>>
lazy_cell
)Implementations§
source§impl<T, F> LazyLock<T, F>where
F: FnOnce() -> T,
impl<T, F> LazyLock<T, F>where
F: FnOnce() -> T,
sourcepub const fn new(f: F) -> LazyLock<T, F>
🔬This is a nightly-only experimental API. (lazy_cell
)
pub const fn new(f: F) -> LazyLock<T, F>
lazy_cell
)Creates a new lazy value with the given initializing function.
sourcepub fn into_inner(this: LazyLock<T, F>) -> Result<T, F>
🔬This is a nightly-only experimental API. (lazy_cell_consume
)
pub fn into_inner(this: LazyLock<T, F>) -> Result<T, F>
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()));
sourcepub fn force(this: &LazyLock<T, F>) -> &T
🔬This is a nightly-only experimental API. (lazy_cell
)
pub fn force(this: &LazyLock<T, F>) -> &T
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> RefUnwindSafe for LazyLock<T, F>
impl<T, F> Sync for LazyLock<T, F>
impl<T, F> UnwindSafe for LazyLock<T, F>where
T: UnwindSafe,
F: UnwindSafe,
Auto Trait Implementations§
Blanket Implementations§
§impl<U> As for U
impl<U> As for U
§fn as_<T>(self) -> Twhere
T: CastFrom<U>,
fn as_<T>(self) -> Twhere
T: CastFrom<U>,
self
to type T
. The semantics of numeric casting with the as
operator are followed, so <T as As>::as_::<U>
can be used in the same way as T as U
for numeric conversions. Read more