Struct Lazy 

pub struct Lazy<'a, A, Config: LazyConfig = RcLazyConfig>(/* private fields */)
where
    A: 'a;

A lazily-computed, memoized value with shared semantics.

The computation runs at most once; subsequent accesses return the cached value. Cloning a Lazy shares the underlying cache - all clones see the same value.

Type Parameters

• A: The type of the computed value.
• Config: The memoization configuration (determines Rc vs Arc).

Fields

• 0: The internal lazy cell.

Examples

use fp_library::types::*;

let memo = Lazy::<_, RcLazyConfig>::new(|| 5);
let shared = memo.clone();

// First force computes and caches:
let value = memo.evaluate();

// Second force returns cached value (shared sees same result):
assert_eq!(shared.evaluate(), value);

Implementations

impl<'a, A, Config: LazyConfig> Lazy<'a, A, Config>

where A: 'a,

pub fn evaluate(&self) -> &A

Gets the memoized value, computing on first access.

Type Signature

A

Returns

A reference to the memoized value.

Examples

use fp_library::types::*;

let memo = Lazy::<_, RcLazyConfig>::new(|| 42);
assert_eq!(*memo.evaluate(), 42);

impl<'a, A> Lazy<'a, A, RcLazyConfig>

where A: 'a,

pub fn new<F>(f: F) -> Self

where F: FnOnce() -> A + 'a,

Creates a new Lazy that will run f on first access.

Type Signature

forall self. (() -> A) -> self

Type Parameters

• F: The type of the initializer closure.

Parameters

• f: The closure that produces the value.

Returns

A new Lazy instance.

Examples

use fp_library::types::*;

let memo = Lazy::<_, RcLazyConfig>::new(|| 42);
assert_eq!(*memo.evaluate(), 42);

pub fn pure(a: A) -> Self

Creates a Lazy from an already-computed value.

The value is immediately available without any computation.

Type Signature

forall self. A -> self

Parameters

• a: The pre-computed value to wrap.

Returns

A new Lazy instance containing the value.

Examples

use fp_library::types::*;

let lazy = Lazy::<_, RcLazyConfig>::pure(42);
assert_eq!(*lazy.evaluate(), 42);

impl<'a, A> Lazy<'a, A, ArcLazyConfig>

where A: 'a,

pub fn new<F>(f: F) -> Self

where F: FnOnce() -> A + Send + 'a,

Creates a new Lazy that will run f on first access.

Type Signature

forall self. (() -> A) -> self

Type Parameters

• F: The type of the initializer closure.

Parameters

• f: The closure that produces the value.

Returns

A new Lazy instance.

Examples

use fp_library::types::*;

let lazy = Lazy::<_, ArcLazyConfig>::new(|| 42);
assert_eq!(*lazy.evaluate(), 42);

pub fn pure(a: A) -> Self

where A: Send,

Creates a Lazy from an already-computed value.

The value is immediately available without any computation. Requires Send since ArcLazy is thread-safe.

Type Signature

forall self. A -> self

Parameters

• a: The pre-computed value to wrap.

Returns

A new Lazy instance containing the value.

Examples

use fp_library::types::*;

let lazy = Lazy::<_, ArcLazyConfig>::pure(42);
assert_eq!(*lazy.evaluate(), 42);

Trait Implementations

impl<'a, A, Config: LazyConfig> Clone for Lazy<'a, A, Config>

where A: 'a,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, A> Deferrable<'a> for Lazy<'a, A, RcLazyConfig>

where A: Clone + 'a,

fn defer<F>(f: F) -> Self

where F: FnOnce() -> Self + 'a, Self: Sized,

Defers a computation that produces a Lazy value.

This flattens the nested structure: instead of Lazy<Lazy<A>>, we get Lazy<A>. The inner Lazy is computed only when the outer Lazy is evaluated.

Type Signature

forall self. Deferrable self => (() -> self) -> self

Type Parameters

• F: The type of the thunk.

Parameters

• f: The thunk that produces the lazy value.

Returns

A new Lazy value.

Examples

use fp_library::{brands::*, classes::*, types::*, functions::*};

let lazy = Lazy::<_, RcLazyConfig>::defer(|| RcLazy::pure(42));
assert_eq!(*lazy.evaluate(), 42);

impl<'a, A, E> From<Lazy<'a, A>> for TryLazy<'a, A, E, RcLazyConfig>

where A: Clone + 'a, E: 'a,

fn from(memo: Lazy<'a, A, RcLazyConfig>) -> Self

Converts to this type from the input type.

impl<'a, A, E> From<Lazy<'a, A, ArcLazyConfig>> for TryLazy<'a, A, E, ArcLazyConfig>

where A: Clone + Send + Sync + 'a, E: Send + Sync + 'a,

fn from(memo: Lazy<'a, A, ArcLazyConfig>) -> Self

Converts to this type from the input type.

impl<'a, A, Config> From<Lazy<'a, A, Config>> for Thunk<'a, A>

where A: Clone + 'a, Config: LazyConfig,

fn from(lazy: Lazy<'a, A, Config>) -> Self

Converts to this type from the input type.

impl<'a, A, E, Config> From<Lazy<'a, A, Config>> for TryThunk<'a, A, E>

where A: Clone + 'a, E: 'a, Config: LazyConfig,

fn from(memo: Lazy<'a, A, Config>) -> Self

Converts to this type from the input type.

impl<A: 'static + Send + Clone, Config: LazyConfig> From<Lazy<'static, A, Config>> for Trampoline<A>

fn from(lazy: Lazy<'static, A, Config>) -> Self

Converts to this type from the input type.

impl<A, E, Config> From<Lazy<'static, A, Config>> for TryTrampoline<A, E>

where A: Clone + Send + 'static, E: Send + 'static, Config: LazyConfig,

fn from(memo: Lazy<'static, A, Config>) -> Self

Converts to this type from the input type.

impl<'a, A> From<Thunk<'a, A>> for Lazy<'a, A, RcLazyConfig>

fn from(eval: Thunk<'a, A>) -> Self

Converts to this type from the input type.

impl<'a, A> From<Trampoline<A>> for Lazy<'a, A, RcLazyConfig>

where A: Send,

fn from(task: Trampoline<A>) -> Self

Converts to this type from the input type.

impl<'a, A> SendDeferrable<'a> for Lazy<'a, A, ArcLazyConfig>

where A: Clone + Send + Sync + 'a,

fn send_defer<F>(f: F) -> Self

where F: FnOnce() -> Self + Send + Sync + 'a, Self: Sized,

Defers a computation that produces a thread-safe Lazy value.

This flattens the nested structure: instead of ArcLazy<ArcLazy<A>>, we get ArcLazy<A>. The inner Lazy is computed only when the outer Lazy is evaluated.

Type Signature

forall self. SendDeferrable self => (() -> self) -> self

Type Parameters

• F: The type of the thunk.

Parameters

• f: The thunk that produces the lazy value.

Returns

A new ArcLazy value.

Examples

use fp_library::{brands::*, classes::*, types::*};

let lazy = ArcLazy::send_defer(|| ArcLazy::pure(42));
assert_eq!(*lazy.evaluate(), 42);