LazyCell in std::cell - Rust (original) (raw)
Struct LazyCell
1.80.0 · Source
pub struct LazyCell<T, F = fn() -> T> { /* private fields */ }Expand description
A value which is initialized on the first access.
For a thread-safe version of this struct, see std::sync::LazyLock.
§Poisoning
If the initialization closure passed to LazyCell::new panics, the cell will be poisoned. Once the cell is poisoned, any threads that attempt to access this cell (via a dereference or via an explicit call to force()) will panic.
This concept is similar to that of poisoning in the std::sync::poison module. A key difference, however, is that poisoning in LazyCell is unrecoverable. All future accesses of the cell from other threads will panic, whereas a type in std::sync::poison likestd::sync::poison::Mutex allows recovery via PoisonError::into_inner().
§Examples
use std::cell::LazyCell;
let lazy: LazyCell<i32> = LazyCell::new(|| {
println!("initializing");
92
});
println!("ready");
println!("{}", *lazy);
println!("{}", *lazy);
// Prints:
// ready
// initializing
// 92
// 921.80.0 (const: 1.80.0) · Source
Creates a new lazy value with the given initializing function.
§Examples
use std::cell::LazyCell;
let hello = "Hello, World!".to_string();
let lazy = LazyCell::new(|| hello.to_uppercase());
assert_eq!(&*lazy, "HELLO, WORLD!");🔬This is a nightly-only experimental API. (lazy_cell_into_inner #125623)
Consumes this LazyCell returning the stored value.
Returns Ok(value) if Lazy is initialized and Err(f) otherwise.
§Panics
Panics if the cell is poisoned.
§Examples
#![feature(lazy_cell_into_inner)]
use std::cell::LazyCell;
let hello = "Hello, World!".to_string();
let lazy = LazyCell::new(|| hello.to_uppercase());
assert_eq!(&*lazy, "HELLO, WORLD!");
assert_eq!(LazyCell::into_inner(lazy).ok(), Some("HELLO, WORLD!".to_string()));1.80.0 · Source
Forces the evaluation of this lazy value and returns a reference to the result.
This is equivalent to the Deref impl, but is explicit.
§Panics
If the initialization closure panics (the one that is passed to the new() method), the panic is propagated to the caller, and the cell becomes poisoned. This will cause all future accesses of the cell (via force() or a dereference) to panic.
§Examples
use std::cell::LazyCell;
let lazy = LazyCell::new(|| 92);
assert_eq!(LazyCell::force(&lazy), &92);
assert_eq!(&*lazy, &92);🔬This is a nightly-only experimental API. (lazy_get #129333)
Forces the evaluation of this lazy value and returns a mutable reference to the result.
§Panics
If the initialization closure panics (the one that is passed to the new() method), the panic is propagated to the caller, and the cell becomes poisoned. This will cause all future accesses of the cell (via force() or a dereference) to panic.
§Examples
#![feature(lazy_get)]
use std::cell::LazyCell;
let mut lazy = LazyCell::new(|| 92);
let p = LazyCell::force_mut(&mut lazy);
assert_eq!(*p, 92);
*p = 44;
assert_eq!(*lazy, 44);🔬This is a nightly-only experimental API. (lazy_get #129333)
Returns a mutable reference to the value if initialized. Otherwise (if uninitialized or poisoned), returns None.
§Examples
#![feature(lazy_get)]
use std::cell::LazyCell;
let mut lazy = LazyCell::new(|| 92);
assert_eq!(LazyCell::get_mut(&mut lazy), None);
let _ = LazyCell::force(&lazy);
*LazyCell::get_mut(&mut lazy).unwrap() = 44;
assert_eq!(*lazy, 44);🔬This is a nightly-only experimental API. (lazy_get #129333)
Returns a reference to the value if initialized. Otherwise (if uninitialized or poisoned), returns None.
§Examples
#![feature(lazy_get)]
use std::cell::LazyCell;
let lazy = LazyCell::new(|| 92);
assert_eq!(LazyCell::get(&lazy), None);
let _ = LazyCell::force(&lazy);
assert_eq!(LazyCell::get(&lazy), Some(&92));Creates a new lazy value using Default as the initializing function.
§Panics
If the initialization closure panics (the one that is passed to the new() method), the panic is propagated to the caller, and the cell becomes poisoned. This will cause all future accesses of the cell (via force() or a dereference) to panic.
The resulting type after dereferencing.
§Panics
If the initialization closure panics (the one that is passed to the new() method), the panic is propagated to the caller, and the cell becomes poisoned. This will cause all future accesses of the cell (via force() or a dereference) to panic.