Skip to main content

Deferrable

fp_library::classes::deferrable

Trait Deferrable 

Source 
pub trait Deferrable<'a> {
    // Required method
    fn defer(f: impl FnOnce() -> Self + 'a) -> Self
       where Self: Sized;
}
Expand description

A type class for types that can be constructed lazily.

Deferrable is the inverse of Extract: where Extract forces/extracts the inner value, Deferrable constructs a value lazily from a thunk. For types whose brand implements Extract (e.g., ThunkBrand), extract(defer(|| x)) == x forms a round-trip. Note that Deferrable is a value-level trait (implemented by concrete types like Thunk), while Extract is a brand-level trait (implemented by ThunkBrand).

§Laws

Deferrable instances must satisfy the following law:

  • Transparency: The value produced by defer(|| x) is identical to x. This law does not constrain when evaluation occurs; some implementations may evaluate eagerly.

§Why there is no generic fix

In PureScript, fix :: Lazy l => (l -> l) -> l enables lazy self-reference, which is essential for tying the knot in recursive values. In Rust, lazy self-reference requires shared ownership (Rc/Arc) and interior mutability, which are properties specific to Lazy rather than all Deferrable types. For example, Thunk is consumed on evaluation, so self-referential construction is not possible.

The concrete functions rc_lazy_fix and arc_lazy_fix provide this capability for Lazy specifically.

§Warning

Some implementations may evaluate the thunk eagerly when the produced type requires Send. For example, ArcLazy’s Deferrable implementation evaluates the outer thunk immediately because ArcLazy::new requires a Send closure, but the Deferrable trait does not impose that bound. If you need guaranteed deferred evaluation with thread-safe types, prefer SendDeferrable instead.

§Type Parameters

  • 'a: The lifetime of the computation.

§Examples

Transparency law for Thunk:

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

// Transparency: defer(|| x) is equivalent to x when evaluated.
let x = Thunk::pure(42);
let deferred: Thunk<i32> = defer(|| Thunk::pure(42));
assert_eq!(deferred.evaluate(), x.evaluate());

Required Methods§

Source

fn defer(f: impl FnOnce() -> Self + 'a) -> Self
where Self: Sized,

Creates a value from a computation that produces the value.

This function takes a thunk and creates a deferred value that will be computed using the thunk.

§Type Signature

(() -> Self) -> Self

§Parameters
  • f: A thunk that produces the value.
§Returns

The deferred value.

§Examples
use fp_library::{
	functions::*,
	types::*,
};

let eval: Thunk<i32> = defer(|| Thunk::pure(42));
assert_eq!(eval.evaluate(), 42);

Implementors§

Source§

impl<'a, A> Deferrable<'a> for Lazy<'a, A, ArcLazyConfig>
where A: Send + Sync + 'a,

§Type Parameters
  • 'a: The lifetime of the reference.
  • A: The type of the computed value.
Source§

impl<'a, A> Deferrable<'a> for Lazy<'a, A, RcLazyConfig>
where A: Clone + 'a,

§Type Parameters
  • 'a: The lifetime of the computation.
  • A: The type of the computed value.
Source§

impl<'a, A, E> Deferrable<'a> for TryLazy<'a, A, E, ArcLazyConfig>
where A: Clone + Send + Sync + 'a, E: Clone + Send + Sync + 'a,

§Type Parameters
  • 'a: The lifetime of the computation.
  • A: The type of the computed value.
  • E: The type of the error.
Source§

impl<'a, A, E> Deferrable<'a> for TryLazy<'a, A, E, RcLazyConfig>
where A: Clone + 'a, E: Clone + 'a,

§Type Parameters
  • 'a: The lifetime of the computation.
  • A: The type of the computed value.
  • E: The type of the error.
Source§

impl<'a, A, E> Deferrable<'a> for TrySendThunk<'a, A, E>
where A: 'a, E: 'a,

§Type Parameters
  • 'a: The lifetime of the computation.
  • A: The type of the success value.
  • E: The type of the error value.
Source§

impl<'a, A, E> Deferrable<'a> for TryThunk<'a, A, E>
where A: 'a, E: 'a,

§Type Parameters
  • 'a: The lifetime of the computation.
  • A: The type of the success value.
  • E: The type of the error value.
Source§

impl<'a, A: 'a> Deferrable<'a> for SendThunk<'a, A>

§Type Parameters
  • 'a: The lifetime of the computation.
  • A: The type of the value produced by the computation.
Source§

impl<'a, A: 'a> Deferrable<'a> for Thunk<'a, A>

§Type Parameters
  • 'a: The lifetime of the computation.
  • A: The type of the value produced by the computation.
Source§

impl<A, E> Deferrable<'static> for TryTrampoline<A, E>
where A: 'static, E: 'static,

§Type Parameters
  • A: The type of the success value.
  • E: The type of the error value.
Source§

impl<A: 'static> Deferrable<'static> for Free<ThunkBrand, A>

§Type Parameters
  • A: The result type.
Source§

impl<A: 'static> Deferrable<'static> for Trampoline<A>

§Type Parameters
  • A: The type of the value produced by the task.