Struct async_once_cell::Lazy

pub struct Lazy<T, F = Pin<Box<dyn Future<Output = T> + Send>>> { /* private fields */ }

A value which is initialized on the first access.

See ConstLazy if you need to initialize in a const context.

use std::sync::Arc;
use async_once_cell::Lazy;

let shared = Arc::new(Lazy::new(async {
    4
}));

let value : &i32 = shared.get().await;
assert_eq!(value, &4);

You can also call await on a reference:

use async_once_cell::Lazy;
struct Foo {
    value: Lazy<i32>,
}

let foo = Foo {
    value : Lazy::new(Box::pin(async { 4 })),
};

assert_eq!((&foo.value).await, &4);

Implementations

impl<T, F> Lazy<T, F> where
    F: Future<Output = T> + Send + 'static, 

pub fn new(future: F) -> Self

Creates a new lazy value with the given initializing future.

pub async fn get(&self) -> &T

Forces the evaluation of this lazy value and returns a reference to the result.

This is equivalent to the Future impl on &Lazy, but is explicit and may be simpler to call. This will panic if the initializing closure panics or has panicked.

impl<T, F> Lazy<T, F>

pub const fn with_value(value: T) -> Self

Creates an already-initialized lazy value.

pub fn try_get(&self) -> Option<&T>

Gets the value without blocking or starting the initialization.

pub fn try_get_mut(&mut self) -> Option<&mut T>

Gets the value without blocking or starting the initialization.

This requires mutable access to self, so rust’s aliasing rules prevent any concurrent access and allow violating the usual rules for accessing this cell.

pub fn into_value(self) -> Option<T>

Gets the value if it was set.

Trait Implementations

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

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

Formats the value using the given formatter.

impl<'a, T, F> Future for &'a Lazy<T, F> where
    F: Future<Output = T> + Send + 'static, 

type Output = &'a T

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<&'a T>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.