Struct Lazy 

pub(super) struct Lazy<T, F> {
    data: AtomicPtr<T>,
    create: F,
    owned: PhantomData<Box<T>>,
}

A non-std lazy initialized value.

This might run the initialization function more than once, but will never block.

I wish I could get these semantics into the non-alloc non-std Lazy type below, but I’m not sure how to do it. If you can do an alloc, then the implementation becomes very simple if you don’t care about redundant work precisely because a pointer can be atomically swapped.

Perhaps making this approach work in the non-alloc non-std case requires asking the caller for a pointer? It would make the API less convenient I think.

Fields

data: AtomicPtr<T>

create: F

owned: PhantomData<Box<T>>

Implementations

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

pub(super) const fn new(create: F) -> Lazy<T, F>

Create a new alloc but non-std lazy value that is racily initialized. That is, the ‘create’ function may be called more than once.

impl<T, F: Fn() -> T> Lazy<T, F>

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

Get the underlying lazy value. If it hasn’t been initialized yet, then always attempt to initialize it (even if some other thread is initializing it) and atomically attach it to this lazy value before returning it.

fn poll(&self) -> Option<&T>

If this lazy value has been initialized successfully, then return that value. Otherwise return None immediately. This never attempts to run initialization itself.

Trait Implementations

impl<T: Debug, F: Fn() -> T> Debug for Lazy<T, F>

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

Formats the value using the given formatter.

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

fn drop(&mut self)

Executes the destructor for this type.

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