Struct Thunk 

pub struct Thunk<'a, A>(/* private fields */);

A deferred computation that produces a value of type A.

Thunk is NOT memoized - each call to Thunk::evaluate re-executes the computation. This type exists to build computation chains without allocation overhead.

Unlike Trampoline, Thunk does NOT require 'static and CAN implement HKT traits like Functor, Semimonad, etc.

Trade-offs vs Trampoline

Aspect	Thunk<'a, A>	Trampoline<A>
HKT compatible	✅ Yes	❌ No (requires 'static)
Stack-safe	⚠️ Partial (tail_rec_m only)	✅ Yes (unlimited)
Lifetime	'a (can borrow)	'static only
Use case	Glue code, composition	Deep recursion, pipelines

Algebraic Properties

Thunk is a proper Monad:

• pure(a).evaluate() == a (left identity).
• thunk.bind(pure) == thunk (right identity).
• thunk.bind(f).bind(g) == thunk.bind(|a| f(a).bind(g)) (associativity).

Type Parameters

• A: The type of the value produced by the computation.

Fields

• 0: The closure that performs the computation.

Examples

use fp_library::types::*;

let computation = Thunk::new(|| 5)
    .map(|x| x * 2)
    .map(|x| x + 1);

// No computation has happened yet!
// Only when we call evaluate() does it execute:
let result = computation.evaluate();
assert_eq!(result, 11);

Implementations

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

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

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

Creates a new Thunk from a thunk.

Type Signature

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

Type Parameters

• F: The type of the thunk.

Parameters

• f: The thunk to wrap.

Returns

A new Thunk instance.

Examples

use fp_library::types::*;

let thunk = Thunk::new(|| 42);
assert_eq!(thunk.evaluate(), 42);

pub fn pure(a: A) -> Self

where A: 'a,

Returns a pure value (already computed).

Type Signature

forall self. A -> self

Parameters

• a: The value to wrap.

Returns

A new Thunk instance containing the value.

Examples

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

let thunk = pure::<ThunkBrand, _>(42);
assert_eq!(thunk.evaluate(), 42);

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

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

Defers a computation that returns a Thunk.

Type Signature

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

Type Parameters

• F: The type of the thunk.

Parameters

• f: The thunk that returns a Thunk.

Returns

A new Thunk instance.

Examples

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

let thunk = Thunk::defer(|| pure::<ThunkBrand, _>(42));
assert_eq!(thunk.evaluate(), 42);

pub fn bind<B: 'a, F>(self, f: F) -> Thunk<'a, B>

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

Monadic bind: chains computations.

Note: Each bind adds to the call stack. For deep recursion, use Trampoline instead.

Type Signature

forall b. (A -> Thunk b) -> Thunk b

Type Parameters

• B: The type of the result of the new computation.
• F: The type of the function to apply.

Parameters

• f: The function to apply to the result of the computation.

Returns

A new Thunk instance representing the chained computation.

Examples

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

let thunk = pure::<ThunkBrand, _>(21).bind(|x| pure::<ThunkBrand, _>(x * 2));
assert_eq!(thunk.evaluate(), 42);

pub fn map<B: 'a, F>(self, f: F) -> Thunk<'a, B>

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

Functor map: transforms the result.

Type Signature

forall b. (A -> b) -> Thunk b

Type Parameters

• B: The type of the result of the transformation.
• F: The type of the transformation function.

Parameters

• f: The function to apply to the result of the computation.

Returns

A new Thunk instance with the transformed result.

Examples

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

let thunk = pure::<ThunkBrand, _>(21).map(|x| x * 2);
assert_eq!(thunk.evaluate(), 42);

pub fn evaluate(self) -> A

Forces evaluation and returns the result.

Type Signature

A

Returns

The result of the computation.

Examples

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

let thunk = pure::<ThunkBrand, _>(42);
assert_eq!(thunk.evaluate(), 42);

Trait Implementations

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

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

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

Creates a Thunk from a computation that produces it.

Type Signature

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

Type Parameters

• F: The type of the thunk.

Parameters

• f: A thunk that produces the thunk.

Returns

The deferred thunk.

Examples

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

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

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> 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: 'a, E: 'a> From<Thunk<'a, A>> for TryThunk<'a, A, E>

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

Converts to this type from the input type.

impl<'a, A: Monoid + 'a> Monoid for Thunk<'a, A>

fn empty() -> Self

Returns the identity Thunk.

Type Signature

forall self. Monoid self => self

Returns

A Thunk producing the identity value of A.

Examples

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

let t: Thunk<String> = Thunk::empty();
assert_eq!(t.evaluate(), "");

impl<'a, A: Semigroup + 'a> Semigroup for Thunk<'a, A>

fn append(a: Self, b: Self) -> Self

Combines two Thunks by combining their results.

Type Signature

forall self. Semigroup self => (self, self) -> self

Parameters

• a: The first Thunk.
• b: The second Thunk.

Returns

A new Thunk containing the combined result.

Examples

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

let t1 = pure::<ThunkBrand, _>("Hello".to_string());
let t2 = pure::<ThunkBrand, _>(" World".to_string());
let t3 = append::<_>(t1, t2);
assert_eq!(t3.evaluate(), "Hello World");