Struct LazyHandle 

pub struct LazyHandle<T> { /* private fields */ }

Handle to a value computed on a background thread.

The computation is spawned immediately on creation and runs concurrently. The result is resolved on first access via Self::get and cached in a OnceLock for subsequent calls.

This type is cheaply cloneable via internal Arc.

Create via Runtime::spawn_blocking_named.

Implementations

impl<T: Send + 'static> LazyHandle<T>

pub fn ready(value: T) -> Self

Creates a handle that is already resolved with the given value.

pub fn get(&self) -> &T

Blocks until the background task completes and returns a reference to the result.

On the first call this awaits the receiver; subsequent calls return the cached value without blocking.

Panics

Panics if the background task was dropped without producing a value.

pub fn try_into_inner(self) -> Result<T, Self>

Consumes the handle and returns the inner value if this is the only handle.

Returns Err(self) if other clones exist, so the caller can fall back to a reference-based path (e.g. clone_into_sorted instead of into_sorted).

Blocks if the background task hasn’t completed yet.

Trait Implementations

impl<T: Clone> Clone for LazyHandle<T>

fn clone(&self) -> LazyHandle<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Send + Debug + 'static> Debug for LazyHandle<T>

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

Formats the value using the given formatter.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes