Trait Supplier 

pub trait Supplier<T> {
    // Required method
    fn get(&mut self) -> T;

    // Provided methods
    fn into_box(self) -> BoxSupplier<T>
       where Self: Sized + 'static,
             T: 'static { ... }
    fn into_rc(self) -> RcSupplier<T>
       where Self: Sized + 'static,
             T: 'static { ... }
    fn into_arc(self) -> ArcSupplier<T>
       where Self: Sized + Send + 'static,
             T: Send + 'static { ... }
    fn into_fn(self) -> impl FnMut() -> T
       where Self: Sized { ... }
    fn to_box(&self) -> BoxSupplier<T>
       where Self: Clone + Sized + 'static,
             T: 'static { ... }
    fn to_rc(&self) -> RcSupplier<T>
       where Self: Clone + Sized + 'static,
             T: 'static { ... }
    fn to_arc(&self) -> ArcSupplier<T>
       where Self: Clone + Sized + Send + 'static,
             T: Send + 'static { ... }
    fn to_fn(&self) -> impl FnMut() -> T
       where Self: Clone + Sized { ... }
}

Supplier trait: generates and returns values without input.

The core abstraction for value generation. Similar to Java’s Supplier<T> interface, it produces values without taking any input parameters.

Key Characteristics

• No input parameters: Pure value generation
• Mutable access: Uses &mut self to allow state changes
• Returns ownership: Returns T (not &T) to avoid lifetime issues
• Can modify state: Commonly used for counters, sequences, and generators

Automatically Implemented for Closures

All FnMut() -> T closures automatically implement this trait, enabling seamless integration with both raw closures and wrapped supplier types.

Examples

Using with Generic Functions

use prism3_function::{Supplier, BoxSupplier};

fn call_twice<S: Supplier<i32>>(supplier: &mut S) -> (i32, i32) {
    (supplier.get(), supplier.get())
}

let mut s = BoxSupplier::new(|| 42);
assert_eq!(call_twice(&mut s), (42, 42));

let mut closure = || 100;
assert_eq!(call_twice(&mut closure), (100, 100));

Stateful Supplier

use prism3_function::Supplier;

let mut counter = 0;
let mut stateful = || {
    counter += 1;
    counter
};

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

Author

Haixing Hu

Required Methods

fn get(&mut self) -> T

Generates and returns the next value.

Executes the underlying function and returns the generated value. Uses &mut self because suppliers typically involve state changes (counters, sequences, etc.).

Returns

The generated value of type T

Examples

use prism3_function::{Supplier, BoxSupplier};

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

Provided Methods

fn into_box(self) -> BoxSupplier<T>

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

Converts to BoxSupplier.

This method has a default implementation that wraps the supplier in a BoxSupplier. Custom implementations can override this for more efficient conversions.

Returns

A new BoxSupplier<T> instance

Examples

use prism3_function::Supplier;

let closure = || 42;
let mut boxed = closure.into_box();
assert_eq!(boxed.get(), 42);

Examples found in repository

examples/supplier_demo.rs (line 38)

fn demo_closure_supplier() {
    println!("--- Closure as Supplier ---");

    // Simple closure
    let closure = || 42;
    let mut boxed = Supplier::into_box(closure);
    println!("Closure: {}", boxed.get());

    // Stateful closure
    let mut counter = 0;
    let stateful = move || {
        counter += 1;
        counter
    };
    let mut boxed_stateful = Supplier::into_box(stateful);
    println!("Counter: {}", boxed_stateful.get());
    println!("Counter: {}", boxed_stateful.get());
    println!("Counter: {}", boxed_stateful.get());
    println!();
}

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

fn into_rc(self) -> RcSupplier<T>

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

Converts to RcSupplier.

This method has a default implementation that wraps the supplier in an RcSupplier. Custom implementations can override this for more efficient conversions.

Returns

A new RcSupplier<T> instance

Examples

use prism3_function::Supplier;

let closure = || 42;
let mut rc = closure.into_rc();
assert_eq!(rc.get(), 42);

Examples found in repository

examples/supplier_demo.rs (line 261)

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

fn into_arc(self) -> ArcSupplier<T>

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

Converts to ArcSupplier.

This method has a default implementation that wraps the supplier in an ArcSupplier. Custom implementations can override this for more efficient conversions.

Returns

A new ArcSupplier<T> instance

Examples

use prism3_function::Supplier;

let closure = || 42;
let mut arc = closure.into_arc();
assert_eq!(arc.get(), 42);

Examples found in repository

examples/supplier_demo.rs (line 266)

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

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

where Self: Sized,

Converts to a closure FnMut() -> T.

This method wraps the supplier in a closure that calls the get() method when invoked. This allows using suppliers in contexts that expect FnMut() closures.

Returns

A closure impl FnMut() -> T

Examples

use prism3_function::{Supplier, BoxSupplier};

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

Using with functions that expect FnMut

use prism3_function::{Supplier, BoxSupplier};

fn call_fn_twice<F: FnMut() -> i32>(mut f: F) -> (i32, i32) {
    (f(), f())
}

let supplier = BoxSupplier::new(|| 100);
let closure = supplier.into_fn();
assert_eq!(call_fn_twice(closure), (100, 100));

fn to_box(&self) -> BoxSupplier<T>

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

Creates a BoxSupplier from a cloned supplier.

Uses Clone to obtain an owned copy and converts it into a BoxSupplier. Implementations can override this for a more efficient conversion.

fn to_rc(&self) -> RcSupplier<T>

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

Creates an RcSupplier from a cloned supplier.

Uses Clone to obtain an owned copy and converts it into an RcSupplier. Implementations can override it for better performance.

fn to_arc(&self) -> ArcSupplier<T>

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

Creates an ArcSupplier from a cloned supplier.

Requires the supplier and produced values to be Send so the resulting supplier can be shared across threads.

fn to_fn(&self) -> impl FnMut() -> T

where Self: Clone + Sized,

Creates a closure from a cloned supplier.

The default implementation clones self and consumes the clone to produce a closure. Concrete suppliers can override it to avoid the additional clone.

Implementors

impl<T> Supplier<T> for ArcSupplier<T>

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

impl<T> Supplier<T> for RcSupplier<T>

impl<T, F> Supplier<T> for F

where F: FnMut() -> T,