Struct BoxStatefulSupplier 

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

Box-based single ownership supplier.

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

Ownership Model

Methods consume self (move semantics). When you call a method like map(), the original supplier is consumed and you get a new one:

use qubit_function::{BoxStatefulSupplier, StatefulSupplier};

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

Examples

Counter

use qubit_function::{BoxStatefulSupplier, StatefulSupplier};

let mut counter = 0;
let mut supplier = BoxStatefulSupplier::new(move || {
    counter += 1;
    counter
});

assert_eq!(supplier.get(), 1);
assert_eq!(supplier.get(), 2);

Method Chaining

use qubit_function::{BoxStatefulSupplier, StatefulSupplier};

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

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

Implementations

impl<T> BoxStatefulSupplier<T>

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

where F: FnMut() -> 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 (lines 85-88)

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!();
}

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

where F: FnMut() -> 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: FnMut() -> 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.

pub fn map<U, M>(self, mapper: M) -> BoxStatefulSupplier<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);

Examples found in repository

examples/suppliers/stateful_supplier_demo.rs (line 104)

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!();
}

examples/suppliers/closure_supplier_ops_demo.rs (line 73)

fn main() {
    println!("=== Closure StatefulSupplier Operations Demo ===\n");

    // 1. FnMut closure using map
    println!("1. FnMut closure using map:");
    let mut counter = 0;
    let mut mapped = (move || {
        counter += 1;
        counter
    })
    .map(|x| x * 2);

    println!("   First call: {}", mapped.get());
    println!("   Second call: {}\n", mapped.get());

    // 2. FnMut closure using filter
    println!("2. FnMut closure using filter:");
    let mut counter2 = 0;
    let mut filtered = (move || {
        counter2 += 1;
        counter2
    })
    .filter(is_even_i32);

    println!("   First call (odd number): {:?}", filtered.get());
    println!("   Second call (even number): {:?}\n", filtered.get());

    // 3. FnMut closure using memoize
    println!("3. FnMut closure using memoize:");
    let mut call_count = 0;
    let mut memoized = (move || {
        call_count += 1;
        println!("   Underlying function called {} times", call_count);
        42
    })
    .memoize();

    println!("   First call: {}", memoized.get());
    println!("   Second call: {}", memoized.get());
    println!("   Third call: {}\n", memoized.get());

    // 4. Fn closure using map (Fn also implements FnMut, so can use FnSupplierOps)
    println!("4. Fn closure using map:");
    let mut mapped_stateless = (|| 10).map(|x| x * 3).map(|x| x + 5);
    println!("   Result: {}\n", mapped_stateless.get());

    // 5. Fn closure using filter (Fn also implements FnMut, so can use FnSupplierOps)
    println!("5. Fn closure using filter:");
    let mut filtered_stateless = (|| 42).filter(is_even_i32);
    println!("   Filtered even number: {:?}\n", filtered_stateless.get());

    // 6. Chained operations
    println!("6. Chained operations:");
    let mut counter3 = 0;
    let mut chained = (move || {
        counter3 += 1;
        counter3
    })
    .map(|x| x * 2)
    .filter(greater_than_five)
    .map(|opt: Option<i32>| opt.unwrap_or(0));

    println!("   First call: {}", chained.get()); // 2, filtered out
    println!("   Second call: {}", chained.get()); // 4, filtered out
    println!("   Third call: {}", chained.get()); // 6, passed
    println!("   Fourth call: {}\n", chained.get()); // 8, passed

    println!("=== Demo completed ===");
}

pub fn filter<P>(self, predicate: P) -> BoxStatefulSupplier<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));

Examples found in repository

examples/suppliers/stateful_supplier_demo.rs (line 114)

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!();
}

examples/suppliers/closure_supplier_ops_demo.rs (line 89)

fn main() {
    println!("=== Closure StatefulSupplier Operations Demo ===\n");

    // 1. FnMut closure using map
    println!("1. FnMut closure using map:");
    let mut counter = 0;
    let mut mapped = (move || {
        counter += 1;
        counter
    })
    .map(|x| x * 2);

    println!("   First call: {}", mapped.get());
    println!("   Second call: {}\n", mapped.get());

    // 2. FnMut closure using filter
    println!("2. FnMut closure using filter:");
    let mut counter2 = 0;
    let mut filtered = (move || {
        counter2 += 1;
        counter2
    })
    .filter(is_even_i32);

    println!("   First call (odd number): {:?}", filtered.get());
    println!("   Second call (even number): {:?}\n", filtered.get());

    // 3. FnMut closure using memoize
    println!("3. FnMut closure using memoize:");
    let mut call_count = 0;
    let mut memoized = (move || {
        call_count += 1;
        println!("   Underlying function called {} times", call_count);
        42
    })
    .memoize();

    println!("   First call: {}", memoized.get());
    println!("   Second call: {}", memoized.get());
    println!("   Third call: {}\n", memoized.get());

    // 4. Fn closure using map (Fn also implements FnMut, so can use FnSupplierOps)
    println!("4. Fn closure using map:");
    let mut mapped_stateless = (|| 10).map(|x| x * 3).map(|x| x + 5);
    println!("   Result: {}\n", mapped_stateless.get());

    // 5. Fn closure using filter (Fn also implements FnMut, so can use FnSupplierOps)
    println!("5. Fn closure using filter:");
    let mut filtered_stateless = (|| 42).filter(is_even_i32);
    println!("   Filtered even number: {:?}\n", filtered_stateless.get());

    // 6. Chained operations
    println!("6. Chained operations:");
    let mut counter3 = 0;
    let mut chained = (move || {
        counter3 += 1;
        counter3
    })
    .map(|x| x * 2)
    .filter(greater_than_five)
    .map(|opt: Option<i32>| opt.unwrap_or(0));

    println!("   First call: {}", chained.get()); // 2, filtered out
    println!("   Second call: {}", chained.get()); // 4, filtered out
    println!("   Third call: {}", chained.get()); // 6, passed
    println!("   Fourth call: {}\n", chained.get()); // 8, passed

    println!("=== Demo completed ===");
}

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

where T: 'static, S: StatefulSupplier<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"));

pub fn memoize(self) -> BoxStatefulSupplier<T>

where T: Clone + 'static,

Creates a memoizing supplier.

Returns a new supplier that caches the first value it produces. All subsequent calls return the cached value.

Returns

A new memoized BoxStatefulSupplier<T>

Examples

use qubit_function::{BoxStatefulSupplier, StatefulSupplier};

let mut call_count = 0;
let mut memoized = BoxStatefulSupplier::new(move || {
    call_count += 1;
    42
}).memoize();

assert_eq!(memoized.get(), 42); // Calls underlying function
assert_eq!(memoized.get(), 42); // Returns cached value

Examples found in repository

examples/suppliers/stateful_supplier_demo.rs (line 131)

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 BoxStatefulSupplier<T>

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

Formats the value using the given formatter.

impl<T> Display for BoxStatefulSupplier<T>

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

Formats the value using the given formatter.

impl<T> StatefulSupplier<T> for BoxStatefulSupplier<T>

fn get(&mut self) -> T

Generates and returns the next value.

fn into_box(self) -> BoxStatefulSupplier<T>

Converts to BoxStatefulSupplier.

fn into_rc(self) -> RcStatefulSupplier<T>

where Self: 'static,

Converts to RcStatefulSupplier.

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

Converts to a closure FnMut() -> T.

fn into_once(self) -> BoxSupplierOnce<T>

where Self: 'static,

Converts to BoxSupplierOnce.

fn into_arc(self) -> ArcStatefulSupplier<T>

where Self: Sized + Send + 'static,

Converts to ArcStatefulSupplier.