Struct BoxSupplier 

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

Box-based single ownership stateless supplier.

Uses Box<dyn Fn() -> T> for single ownership scenarios. This is the most lightweight stateless supplier with zero reference counting overhead.

Ownership Model

Methods consume self (move semantics) or borrow &self for read-only operations. When you call methods like map(), the original supplier is consumed and you get a new one:

use qubit_function::{BoxSupplier, Supplier};

let supplier = BoxSupplier::new(|| 10);
let mapped = supplier.map(|x| x * 2);
// supplier is no longer usable here

Examples

Constant Factory

use qubit_function::{BoxSupplier, Supplier};

let factory = BoxSupplier::new(|| 42);
assert_eq!(factory.get(), 42);
assert_eq!(factory.get(), 42);

Method Chaining

use qubit_function::{BoxSupplier, Supplier};

let pipeline = BoxSupplier::new(|| 10)
    .map(|x| x * 2)
    .map(|x| x + 5);

assert_eq!(pipeline.get(), 25);

Implementations

impl<T> BoxSupplier<T>

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

where F: Fn() -> T + 'static,

Creates a new supplier.

Wraps the provided closure in the appropriate smart pointer type for this supplier implementation.

Examples found in repository

examples/suppliers/stateful_supplier_demo.rs (line 75)

fn demo_box_supplier_basics() {
    println!("--- BoxSupplier Basics ---");

    // Basic usage (Fn)
    let supplier = BoxSupplier::new(|| 42);
    println!("Basic: {}", supplier.get());

    // Constant supplier (Fn)
    let constant = BoxSupplier::constant(100);
    println!("Constant: {}", constant.get());
    println!("Constant: {}", constant.get());

    // Stateful counter (FnMut) - use BoxStatefulSupplier
    let mut counter = 0;
    let mut counter_supplier = BoxStatefulSupplier::new(move || {
        counter += 1;
        counter
    });
    println!("Counter: {}", counter_supplier.get());
    println!("Counter: {}", counter_supplier.get());
    println!("Counter: {}", counter_supplier.get());
    println!();
}

fn demo_box_supplier_methods() {
    println!("--- BoxStatefulSupplier Methods ---");

    // Map (FnMut)
    let mut counter = 0;
    let mut mapped = BoxStatefulSupplier::new(move || {
        counter += 1;
        counter * 10
    })
    .map(|x| x + 5);
    println!("Mapped: {}", mapped.get());
    println!("Mapped: {}", mapped.get());

    // Filter (FnMut)
    let mut counter = 0;
    let mut filtered = BoxStatefulSupplier::new(move || {
        counter += 1;
        counter
    })
    .filter(is_even_i32);
    println!("Filtered (odd): {:?}", filtered.get());
    println!("Filtered (even): {:?}", filtered.get());

    // Zip (Fn)
    let first = BoxSupplier::new(|| 42);
    let second = BoxSupplier::new(|| "hello");
    let zipped = first.zip(second);
    println!("Zipped: {:?}", zipped.get());

    // Memoize (FnMut)
    let mut call_count = 0;
    let mut memoized = BoxStatefulSupplier::new(move || {
        call_count += 1;
        println!("  Expensive computation #{}", call_count);
        42
    })
    .memoize();
    println!("First call: {}", memoized.get());
    println!("Second call (cached): {}", memoized.get());
    println!();
}

fn demo_box_supplier_once() {
    println!("--- BoxSupplierOnce ---");

    // Basic usage
    let once = BoxSupplierOnce::new(|| {
        println!("  Expensive initialization");
        42
    });
    println!("Value: {}", once.get());

    // Moving captured values
    let data = String::from("Hello, World!");
    let once = BoxSupplierOnce::new(move || data);
    println!("Moved data: {}", once.get());
    println!();
}

fn demo_arc_supplier() {
    println!("--- ArcSupplier ---");

    // Basic usage (Fn)
    let supplier = ArcSupplier::new(|| 42);
    let s = supplier;
    println!("Basic: {}", s.get());

    // Reusable transformations (Fn)
    let source = ArcSupplier::new(|| 10);
    let doubled = source.map(|x| x * 2);
    let tripled = source.map(|x| x * 3);

    let s = source;
    let d = doubled;
    let t = tripled;
    println!("Source: {}", s.get());
    println!("Doubled: {}", d.get());
    println!("Tripled: {}", t.get());

    // Stateful with ArcStatefulSupplier (FnMut)
    let call_count = Arc::new(Mutex::new(0));
    let call_count_clone = Arc::clone(&call_count);
    let source = ArcStatefulSupplier::new(move || {
        let mut c = call_count_clone
            .lock()
            .expect("mutex should not be poisoned");
        *c += 1;
        println!("  Computation #{}", *c);
        42
    });

    // Memoization with ArcStatefulSupplier
    let memoized = source.memoize();
    let mut m = memoized;
    println!("First call: {}", m.get());
    println!("Second call (cached): {}", m.get());
    println!(
        "Call count: {}",
        *call_count.lock().expect("mutex should not be poisoned")
    );
    println!();
}

fn demo_arc_supplier_threading() {
    println!("--- ArcStatefulSupplier Threading ---");

    let counter = Arc::new(Mutex::new(0));
    let counter_clone = Arc::clone(&counter);

    let supplier = ArcStatefulSupplier::new(move || {
        let mut c = counter_clone.lock().expect("mutex should not be poisoned");
        *c += 1;
        *c
    });

    let mut s1 = supplier.clone();
    let mut s2 = supplier.clone();
    let mut s3 = supplier;

    let h1 = thread::spawn(move || {
        let v1 = s1.get();
        let v2 = s1.get();
        println!("Thread 1: {} {}", v1, v2);
        (v1, v2)
    });

    let h2 = thread::spawn(move || {
        let v1 = s2.get();
        let v2 = s2.get();
        println!("Thread 2: {} {}", v1, v2);
        (v1, v2)
    });

    let v1 = s3.get();
    let v2 = s3.get();
    println!("Main thread: {} {}", v1, v2);

    h1.join().expect("thread should not panic");
    h2.join().expect("thread should not panic");

    println!(
        "Final counter: {}",
        *counter.lock().expect("mutex should not be poisoned")
    );
    println!();
}

fn demo_rc_supplier() {
    println!("--- RcSupplier ---");

    // Basic usage (Fn)
    let supplier = RcSupplier::new(|| 42);
    let s = supplier;
    println!("Basic: {}", s.get());

    // Shared state (FnMut) - use RcStatefulSupplier
    let counter = Rc::new(RefCell::new(0));
    let counter_clone = Rc::clone(&counter);
    let supplier = RcStatefulSupplier::new(move || {
        let mut c = counter_clone.borrow_mut();
        *c += 1;
        *c
    });

    let mut s1 = supplier.clone();
    let mut s2 = supplier.clone();

    println!("First clone: {}", s1.get());
    println!("Second clone: {}", s2.get());
    println!("First clone again: {}", s1.get());

    // Reusable transformations (Fn)
    let source = RcSupplier::new(|| 10);
    let doubled = source.map(|x| x * 2);
    let tripled = source.map(|x| x * 3);
    let squared = source.map(|x| x * x);

    let s = source;
    let d = doubled;
    let t = tripled;
    let sq = squared;

    println!("Source: {}", s.get());
    println!("Doubled: {}", d.get());
    println!("Tripled: {}", t.get());
    println!("Squared: {}", sq.get());
    println!();
}

fn demo_type_conversions() {
    println!("--- Type Conversions ---");

    // Closure to Box (Fn)
    let closure = || 42;
    let boxed = Supplier::into_box(closure);
    println!("Closure -> Box: {}", boxed.get());

    // Closure to Rc (Fn)
    let closure = || 100;
    let rc = Supplier::into_rc(closure);
    println!("Closure -> Rc: {}", rc.get());

    // Closure to Arc (Fn)
    let closure = || 200;
    let arc = Supplier::into_arc(closure);
    println!("Closure -> Arc: {}", arc.get());

    // Box to Rc (Fn)
    let boxed = BoxSupplier::new(|| 42);
    let rc = boxed.into_rc();
    println!("Box -> Rc: {}", rc.get());

    // Arc to Box (Fn)
    let arc = ArcSupplier::new(|| 42);
    let boxed = arc.into_box();
    println!("Arc -> Box: {}", boxed.get());

    // Rc to Box (Fn)
    let rc = RcSupplier::new(|| 42);
    let boxed = rc.into_box();
    println!("Rc -> Box: {}", boxed.get());

    println!();
}

pub fn new_with_name<F>(name: &str, f: F) -> Self

where F: Fn() -> T + 'static,

Creates a new named supplier.

Wraps the provided closure and assigns it a name, which is useful for debugging and logging purposes.

pub fn new_with_optional_name<F>(f: F, name: Option<String>) -> Self

where F: Fn() -> T + 'static,

Creates a new named supplier with an optional name.

Wraps the provided closure and assigns it an optional name.

pub fn name(&self) -> Option<&str>

Gets the name of this supplier.

Returns

Returns Some(&str) if a name was set, None otherwise.

pub fn set_name(&mut self, name: &str)

Sets the name of this supplier.

Parameters

• name - The name to set for this supplier

pub fn clear_name(&mut self)

Clears the name of this supplier.

pub fn constant(value: T) -> Self

where T: Clone + 'static,

Creates a supplier that returns a constant value.

Creates a supplier that always returns the same value. Useful for default values or placeholder implementations.

Parameters

• value - The constant value to return

Returns

Returns a new supplier instance that returns the constant value.

Examples found in repository

examples/suppliers/stateful_supplier_demo.rs (line 79)

fn demo_box_supplier_basics() {
    println!("--- BoxSupplier Basics ---");

    // Basic usage (Fn)
    let supplier = BoxSupplier::new(|| 42);
    println!("Basic: {}", supplier.get());

    // Constant supplier (Fn)
    let constant = BoxSupplier::constant(100);
    println!("Constant: {}", constant.get());
    println!("Constant: {}", constant.get());

    // Stateful counter (FnMut) - use BoxStatefulSupplier
    let mut counter = 0;
    let mut counter_supplier = BoxStatefulSupplier::new(move || {
        counter += 1;
        counter
    });
    println!("Counter: {}", counter_supplier.get());
    println!("Counter: {}", counter_supplier.get());
    println!("Counter: {}", counter_supplier.get());
    println!();
}

pub fn map<U, M>(self, mapper: M) -> BoxSupplier<U>

where T: 'static, M: Transformer<T, U> + 'static, U: 'static,

Maps the output using a transformation function.

Consumes self and returns a new supplier that applies the mapper to each output.

Parameters

• mapper - The transformer to apply to the output. Can be a closure, function pointer, or any type implementing Transformer<T, U>.

Returns

A new mapped supplier

Examples

use qubit_function::suppliers::*;

let supplier = BoxSupplier::new(|| 10);
let mapped = supplier
    .map(|x| x * 2)
    .map(|x| x + 5);
assert_eq!(mapped.get(), 25);

pub fn filter<P>(self, predicate: P) -> BoxSupplier<Option<T>>

where T: 'static, P: Predicate<T> + 'static,

Filters output based on a predicate.

Returns a new supplier that returns Some(value) if the predicate is satisfied, None otherwise.

Parameters

• predicate - The predicate to test the supplied value

Returns

A new filtered supplier

Examples

use qubit_function::predicates::BoxPredicate;
use qubit_function::{Predicate, suppliers::*};

let supplier = BoxSupplier::new(|| 42);
let is_even = BoxPredicate::new(|x: &i32| *x % 2 == 0);
let filtered = supplier.filter(is_even);

assert_eq!(filtered.get(), Some(42));

pub fn zip<U, S>(self, other: S) -> BoxSupplier<(T, U)>

where T: 'static, S: Supplier<U> + 'static, U: 'static,

Combines this supplier with another, producing a tuple.

Consumes both suppliers and returns a new supplier that produces tuples.

Parameters

• other - The other supplier to combine with

Returns

A new supplier that produces tuples

Examples

use qubit_function::suppliers::*;

let first = BoxSupplier::new(|| 42);
let second = BoxSupplier::new(|| "hello");
let zipped = first.zip(second);

assert_eq!(zipped.get(), (42, "hello"));

Examples found in repository

examples/suppliers/stateful_supplier_demo.rs (line 121)

fn demo_box_supplier_methods() {
    println!("--- BoxStatefulSupplier Methods ---");

    // Map (FnMut)
    let mut counter = 0;
    let mut mapped = BoxStatefulSupplier::new(move || {
        counter += 1;
        counter * 10
    })
    .map(|x| x + 5);
    println!("Mapped: {}", mapped.get());
    println!("Mapped: {}", mapped.get());

    // Filter (FnMut)
    let mut counter = 0;
    let mut filtered = BoxStatefulSupplier::new(move || {
        counter += 1;
        counter
    })
    .filter(is_even_i32);
    println!("Filtered (odd): {:?}", filtered.get());
    println!("Filtered (even): {:?}", filtered.get());

    // Zip (Fn)
    let first = BoxSupplier::new(|| 42);
    let second = BoxSupplier::new(|| "hello");
    let zipped = first.zip(second);
    println!("Zipped: {:?}", zipped.get());

    // Memoize (FnMut)
    let mut call_count = 0;
    let mut memoized = BoxStatefulSupplier::new(move || {
        call_count += 1;
        println!("  Expensive computation #{}", call_count);
        42
    })
    .memoize();
    println!("First call: {}", memoized.get());
    println!("Second call (cached): {}", memoized.get());
    println!();
}

Trait Implementations

impl<T> Debug for BoxSupplier<T>

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

Formats the value using the given formatter.

impl<T> Display for BoxSupplier<T>

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

Formats the value using the given formatter.

impl<T> Supplier<T> for BoxSupplier<T>

fn get(&self) -> T

Generates and returns a value.

fn into_box(self) -> BoxSupplier<T>

Converts to BoxSupplier.

fn into_rc(self) -> RcSupplier<T>

where Self: 'static,

Converts to RcSupplier.

fn into_fn(self) -> impl Fn() -> T

Converts to a closure implementing Fn() -> T.

fn into_once(self) -> BoxSupplierOnce<T>

where Self: 'static,

Converts to BoxSupplierOnce.

fn into_arc(self) -> ArcSupplier<T>

where Self: Sized + Send + Sync + 'static,

Converts to ArcSupplier.