Struct BoxSupplier 

pub struct BoxSupplier<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 prism3_function::{BoxSupplier, Supplier};

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

Examples

Counter

use prism3_function::{BoxSupplier, Supplier};

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

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

Method Chaining

use prism3_function::{BoxSupplier, Supplier};

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

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

Author

Haixing Hu

Implementations

impl<T> BoxSupplier<T>

where T: 'static,

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

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

Creates a new BoxSupplier.

Parameters

• f - The closure to wrap

Returns

A new BoxSupplier<T> instance

Examples

use prism3_function::{BoxSupplier, Supplier};

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

Examples found in repository

examples/supplier_demo.rs (line 58)

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

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

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

    // Stateful counter
    let mut counter = 0;
    let mut counter_supplier = BoxSupplier::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!("--- BoxSupplier Methods ---");

    // Map
    let mut mapped = BoxSupplier::new(|| 10).map(|x| x * 2).map(|x| x + 5);
    println!("Mapped: {}", mapped.get());

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

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

    // Memoize
    let mut call_count = 0;
    let mut memoized = BoxSupplier::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
    let supplier = ArcSupplier::new(|| 42);
    let mut s = supplier;
    println!("Basic: {}", s.get());

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

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

    // Memoization
    let call_count = Arc::new(Mutex::new(0));
    let call_count_clone = Arc::clone(&call_count);
    let source = ArcSupplier::new(move || {
        let mut c = call_count_clone.lock().unwrap();
        *c += 1;
        println!("  Computation #{}", *c);
        42
    });
    let memoized = source.memoize();

    let mut m = memoized;
    println!("First call: {}", m.get());
    println!("Second call (cached): {}", m.get());
    println!();
}

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

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

    let supplier = ArcSupplier::new(move || {
        let mut c = counter_clone.lock().unwrap();
        *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().unwrap();
    h2.join().unwrap();

    println!("Final counter: {}", *counter.lock().unwrap());
    println!();
}

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

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

    // Shared state
    let counter = Rc::new(RefCell::new(0));
    let counter_clone = Rc::clone(&counter);
    let supplier = RcSupplier::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
    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 mut s = source;
    let mut d = doubled;
    let mut t = tripled;
    let mut 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
    let closure = || 42;
    let mut boxed = Supplier::into_box(closure);
    println!("Closure -> Box: {}", boxed.get());

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

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

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

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

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

    println!();
}

pub fn constant(value: T) -> Self

where T: Clone + 'static,

Creates a constant supplier.

Returns a supplier that always produces the same value (via cloning).

Parameters

• value - The constant value to return

Returns

A constant supplier

Examples

use prism3_function::{BoxSupplier, Supplier};

let mut constant = BoxSupplier::constant(42);
assert_eq!(constant.get(), 42);
assert_eq!(constant.get(), 42);

Examples found in repository

examples/supplier_demo.rs (line 62)

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

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

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

    // Stateful counter
    let mut counter = 0;
    let mut counter_supplier = BoxSupplier::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, F>(self, mapper: F) -> BoxSupplier<U>

where F: Mapper<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 mapper to apply to the output. Can be:
  • A closure: |x: T| -> U
  • A function pointer: fn(T) -> U
  • A BoxMapper<T, U>, RcMapper<T, U>, ArcMapper<T, U>
  • Any type implementing Mapper<T, U>

Returns

A new mapped BoxSupplier<U>

Examples

Using with closure

use prism3_function::{BoxSupplier, Supplier};

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

Using with Mapper object

use prism3_function::{BoxSupplier, BoxMapper, Supplier, Mapper};

let mapper = BoxMapper::new(|x: i32| x * 2);
let mut supplier = BoxSupplier::new(|| 10)
    .map(mapper);
assert_eq!(supplier.get(), 20);

Examples found in repository

examples/supplier_demo.rs (line 82)

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

    // Map
    let mut mapped = BoxSupplier::new(|| 10).map(|x| x * 2).map(|x| x + 5);
    println!("Mapped: {}", mapped.get());

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

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

    // Memoize
    let mut call_count = 0;
    let mut memoized = BoxSupplier::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/closure_supplier_ops_demo.rs (line 61)

fn main() {
    println!("=== Closure Supplier 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(|x| x % 2 == 0);

    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_readonly = (|| 10).map(|x| x * 3).map(|x| x + 5);
    println!("   Result: {}\n", mapped_readonly.get());

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

    // 6. Chained operations
    println!("6. Chained operations:");
    let mut counter3 = 0;
    let mut chained = (move || {
        counter3 += 1;
        counter3
    })
    .map(|x| x * 2)
    .filter(|x| *x > 5)
    .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) -> BoxSupplier<Option<T>>

where P: FnMut(&T) -> bool + '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 BoxSupplier<Option<T>>

Examples

use prism3_function::{BoxSupplier, Supplier};

let mut counter = 0;
let mut filtered = BoxSupplier::new(move || {
    counter += 1;
    counter
}).filter(|x| x % 2 == 0);

assert_eq!(filtered.get(), None);     // 1 is odd
assert_eq!(filtered.get(), Some(2));  // 2 is even

Examples found in repository

examples/supplier_demo.rs (line 91)

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

    // Map
    let mut mapped = BoxSupplier::new(|| 10).map(|x| x * 2).map(|x| x + 5);
    println!("Mapped: {}", mapped.get());

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

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

    // Memoize
    let mut call_count = 0;
    let mut memoized = BoxSupplier::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/closure_supplier_ops_demo.rs (line 77)

fn main() {
    println!("=== Closure Supplier 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(|x| x % 2 == 0);

    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_readonly = (|| 10).map(|x| x * 3).map(|x| x + 5);
    println!("   Result: {}\n", mapped_readonly.get());

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

    // 6. Chained operations
    println!("6. Chained operations:");
    let mut counter3 = 0;
    let mut chained = (move || {
        counter3 += 1;
        counter3
    })
    .map(|x| x * 2)
    .filter(|x| *x > 5)
    .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>(self, other: BoxSupplier<U>) -> BoxSupplier<(T, U)>

where U: 'static,

Combines this supplier with another, producing a tuple.

Consumes both suppliers and returns a new supplier that produces (T, U) tuples.

Parameters

• other - The other supplier to combine with

Returns

A new BoxSupplier<(T, U)>

Examples

use prism3_function::{BoxSupplier, Supplier};

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

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

Examples found in repository

examples/supplier_demo.rs (line 98)

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

    // Map
    let mut mapped = BoxSupplier::new(|| 10).map(|x| x * 2).map(|x| x + 5);
    println!("Mapped: {}", mapped.get());

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

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

    // Memoize
    let mut call_count = 0;
    let mut memoized = BoxSupplier::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 memoize(self) -> BoxSupplier<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 BoxSupplier<T>

Examples

use prism3_function::{BoxSupplier, Supplier};

let mut call_count = 0;
let mut memoized = BoxSupplier::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/supplier_demo.rs (line 108)

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

    // Map
    let mut mapped = BoxSupplier::new(|| 10).map(|x| x * 2).map(|x| x + 5);
    println!("Mapped: {}", mapped.get());

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

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

    // Memoize
    let mut call_count = 0;
    let mut memoized = BoxSupplier::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> Supplier<T> for BoxSupplier<T>

fn get(&mut self) -> T

Generates and returns the next value.

fn into_box(self) -> BoxSupplier<T>

where T: 'static,

Converts to BoxSupplier.

fn into_rc(self) -> RcSupplier<T>

where T: 'static,

Converts to RcSupplier.

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

Converts to a closure FnMut() -> T.

fn into_arc(self) -> ArcSupplier<T>

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

Converts to ArcSupplier.