pub struct LazyCell<T, F = fn() -> T> { /* private fields */ }
A value which is initialized on the first access.
For a thread-safe version of this struct, see std::sync::LazyLock.
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 like std::sync::poison::Mutex allows recovery via PoisonError::into_inner().
use std::cell::LazyCell;
let lazy: LazyCell<i32> = LazyCell::new(|| {
println!("initializing");
92
});
println!("ready");
println!("{}", *lazy);
println!("{}", *lazy);
// Prints:
// ready
// initializing
// 92
// 92impl<T, F> LazyCell<T, F>where
F: FnOnce() -> T,pub const fn new(f: F) -> LazyCell<T, F>
Creates a new lazy value with the given initializing function.
use std::cell::LazyCell; let hello = "Hello, World!".to_string(); let lazy = LazyCell::new(|| hello.to_uppercase()); assert_eq!(&*lazy, "HELLO, WORLD!");
pub const fn into_inner(this: LazyCell<T, F>) -> Result<T, F>
lazy_cell_into_inner #125623)
Consumes this LazyCell returning the stored value.
Returns Ok(value) if Lazy is initialized and Err(f) otherwise.
Panics if the cell is poisoned.
#![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()));pub fn force(this: &LazyCell<T, F>) -> &T
Forces the evaluation of this lazy value and returns a reference to the result.
This is equivalent to the Deref impl, but is explicit.
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.
use std::cell::LazyCell; let lazy = LazyCell::new(|| 92); assert_eq!(LazyCell::force(&lazy), &92); assert_eq!(&*lazy, &92);
pub fn force_mut(this: &mut LazyCell<T, F>) -> &mut T
lazy_get #129333)
Forces the evaluation of this lazy value and returns a mutable reference to the result.
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.
#![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);
impl<T, F> LazyCell<T, F>
pub fn get_mut(this: &mut LazyCell<T, F>) -> Option<&mut T>
lazy_get #129333)
Returns a mutable reference to the value if initialized. Otherwise (if uninitialized or poisoned), returns None.
#![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);
pub fn get(this: &LazyCell<T, F>) -> Option<&T>
lazy_get #129333)
Returns a reference to the value if initialized. Otherwise (if uninitialized or poisoned), returns None.
#![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));
impl<T, F> Debug for LazyCell<T, F>where
T: Debug,fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
impl<T> Default for LazyCell<T>where
T: Default,fn default() -> LazyCell<T>
Creates a new lazy value using Default as the initializing function.
impl<T, F> Deref for LazyCell<T, F>where
F: FnOnce() -> T,fn deref(&self) -> &T
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.
type Target = T
impl<T, F> DerefMut for LazyCell<T, F>where
F: FnOnce() -> T,impl<T, F = fn() -> T> !Freeze for LazyCell<T, F>
impl<T, F = fn() -> T> !RefUnwindSafe for LazyCell<T, F>
impl<T, F> Send for LazyCell<T, F>where
F: Send,
T: Send,impl<T, F = fn() -> T> !Sync for LazyCell<T, F>
impl<T, F> Unpin for LazyCell<T, F>where
F: Unpin,
T: Unpin,impl<T, F> UnwindSafe for LazyCell<T, F>where
F: UnwindSafe,
T: UnwindSafe,impl<T> Any for Twhere
T: 'static + ?Sized,impl<T> Borrow<T> for Twhere
T: ?Sized,impl<T> BorrowMut<T> for Twhere
T: ?Sized,impl<T> From<T> for T
fn from(t: T) -> T
Returns the argument unchanged.
impl<T, U> Into<U> for Twhere
U: From<T>,fn into(self) -> U
Calls U::from(self).
That is, this conversion is whatever the implementation of From<T> for U chooses to do.
impl<P, T> Receiver for Pwhere
P: Deref<Target = T> + ?Sized,
T: ?Sized,type Target = T
arbitrary_self_types #44874)
impl<T, U> TryFrom<U> for Twhere
U: Into<T>,type Error = Infallible
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/cell/struct.LazyCell.html