Struct BoxBiConsumer 

pub struct BoxBiConsumer<T, U> { /* private fields */ }

BoxBiConsumer struct

A bi-consumer implementation based on Box<dyn FnMut(&T, &U)> for single ownership scenarios. This is the simplest and most efficient bi-consumer type when sharing is not required.

Features

• Single Ownership: Not cloneable, ownership moves on use
• Zero Overhead: No reference counting or locking
• Mutable State: Can modify captured environment via FnMut
• Builder Pattern: Method chaining consumes self naturally

Use Cases

Choose BoxBiConsumer when:

• The bi-consumer is used only once or in a linear flow
• Building pipelines where ownership naturally flows
• No need to share the consumer across contexts
• Performance is critical and sharing overhead is unacceptable

Performance

BoxBiConsumer has the best performance among the three bi-consumer types:

• No reference counting overhead
• No lock acquisition or runtime borrow checking
• Direct function call through vtable
• Minimal memory footprint (single pointer)

Examples

use prism3_function::{BiConsumer, BoxBiConsumer};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l = log.clone();
let mut consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
    l.lock().unwrap().push(*x + *y);
});
consumer.accept(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![8]);

Author

Haixing Hu

Implementations

impl<T, U> BoxBiConsumer<T, U>

where T: 'static, U: 'static,

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

where F: FnMut(&T, &U) + 'static,

Creates a new BoxBiConsumer

Type Parameters

• F - The closure type

Parameters

• f - The closure to wrap

Returns

Returns a new BoxBiConsumer<T, U> instance

Examples

use prism3_function::{BiConsumer, BoxBiConsumer};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l = log.clone();
let mut consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
    l.lock().unwrap().push(*x * 2 + *y);
});
consumer.accept(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![13]);

Examples found in repository

examples/bi_consumer_demo.rs (lines 28-31)

fn main() {
    println!("=== BiConsumer Demo ===\n");

    // 1. BoxBiConsumer - Single ownership
    println!("1. BoxBiConsumer - Single ownership:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut box_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        println!("  Processing: x={}, y={}", x, y);
        l.lock().unwrap().push(*x + *y);
    });
    box_consumer.accept(&10, &5);
    println!("  Result log: {:?}\n", *log.lock().unwrap());

    // 2. Method chaining with BoxBiConsumer
    println!("2. BoxBiConsumer with method chaining:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let mut chained = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        l1.lock().unwrap().push(*x + *y);
        println!("  After first operation: sum = {}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock().unwrap().push(*x * *y);
        println!("  After second operation: product = {}", x * y);
    });
    chained.accept(&5, &3);
    println!("  Final log: {:?}\n", *log.lock().unwrap());

    // 3. ArcBiConsumer - Thread-safe shared ownership
    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
        println!("  Thread {:?}: sum = {}", thread::current().id(), x + y);
    });

    let consumer1 = arc_consumer.clone();
    let consumer2 = arc_consumer.clone();

    let handle1 = thread::spawn(move || {
        let mut c = consumer1;
        c.accept(&10, &5);
    });

    let handle2 = thread::spawn(move || {
        let mut c = consumer2;
        c.accept(&20, &8);
    });

    handle1.join().unwrap();
    handle2.join().unwrap();
    println!("  Final log: {:?}\n", *log.lock().unwrap());

    // 4. RcBiConsumer - Single-threaded shared ownership
    println!("4. RcBiConsumer - Single-threaded shared ownership:");
    let log = Rc::new(RefCell::new(Vec::new()));
    let l = log.clone();
    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
        l.borrow_mut().push(*x + *y);
    });

    let mut clone1 = rc_consumer.clone();
    let mut clone2 = rc_consumer.clone();

    clone1.accept(&5, &3);
    println!("  After first use: {:?}", *log.borrow());

    clone2.accept(&7, &2);
    println!("  After second use: {:?}\n", *log.borrow());

    // 5. Working with closures directly
    println!("5. Working with closures directly:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut closure = move |x: &i32, y: &i32| {
        let sum = *x + *y;
        l.lock().unwrap().push(sum);
    };
    closure.accept(&10, &20);
    println!("  After closure: {:?}\n", *log.lock().unwrap());

    // 6. Conditional BiConsumer
    println!("6. Conditional BiConsumer:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut conditional = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);

    conditional.accept(&5, &3);
    println!("  Positive values: {:?}", *log.lock().unwrap());

    conditional.accept(&-5, &3);
    println!("  Negative value (unchanged): {:?}\n", *log.lock().unwrap());

    // 7. Conditional branch BiConsumer
    println!("7. Conditional branch BiConsumer:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let mut branch = BoxBiConsumer::new(move |x: &i32, _y: &i32| {
        l1.lock().unwrap().push(*x);
    })
    .when(|x: &i32, y: &i32| *x > *y)
    .or_else(move |_x: &i32, y: &i32| {
        l2.lock().unwrap().push(*y);
    });

    branch.accept(&15, &10);
    println!("  When x > y: {:?}", *log.lock().unwrap());

    branch.accept(&5, &10);
    println!("  When x <= y: {:?}\n", *log.lock().unwrap());

    // 8. Accumulating statistics
    println!("8. Accumulating statistics:");
    let count = Arc::new(Mutex::new(0));
    let sum = Arc::new(Mutex::new(0));
    let c = count.clone();
    let s = sum.clone();
    let mut stats_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        *c.lock().unwrap() += 1;
        *s.lock().unwrap() += x + y;
    });

    stats_consumer.accept(&5, &3);
    stats_consumer.accept(&10, &2);
    stats_consumer.accept(&7, &8);

    println!("  Count: {}", *count.lock().unwrap());
    println!("  Sum: {}\n", *sum.lock().unwrap());

    // 9. Name support
    println!("9. Name support:");
    let mut named_consumer = BoxBiConsumer::<i32, i32>::noop();
    println!("  Initial name: {:?}", named_consumer.name());

    named_consumer.set_name("sum_calculator");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}\n", named_consumer);

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

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

where F: FnMut(&T, &U) + 'static,

Creates a new BoxBiConsumer with a name

Type Parameters

• F - The closure type

Parameters

• name - The name of the consumer
• f - The closure to wrap

Returns

Returns a new BoxBiConsumer<T, U> instance with the specified name

Examples

use prism3_function::{BiConsumer, BoxBiConsumer};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l = log.clone();
let mut consumer = BoxBiConsumer::new_with_name("sum_logger", move |x: &i32, y: &i32| {
    l.lock().unwrap().push(*x + *y);
});
assert_eq!(consumer.name(), Some("sum_logger"));
consumer.accept(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![8]);

pub fn noop() -> Self

Creates a no-op bi-consumer

Returns a bi-consumer that performs no operation.

Returns

Returns a no-op bi-consumer

Examples

use prism3_function::{BiConsumer, BoxBiConsumer};

let mut noop = BoxBiConsumer::<i32, i32>::noop();
noop.accept(&42, &10);
// Values unchanged

Examples found in repository

examples/bi_consumer_demo.rs (line 159)

fn main() {
    println!("=== BiConsumer Demo ===\n");

    // 1. BoxBiConsumer - Single ownership
    println!("1. BoxBiConsumer - Single ownership:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut box_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        println!("  Processing: x={}, y={}", x, y);
        l.lock().unwrap().push(*x + *y);
    });
    box_consumer.accept(&10, &5);
    println!("  Result log: {:?}\n", *log.lock().unwrap());

    // 2. Method chaining with BoxBiConsumer
    println!("2. BoxBiConsumer with method chaining:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let mut chained = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        l1.lock().unwrap().push(*x + *y);
        println!("  After first operation: sum = {}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock().unwrap().push(*x * *y);
        println!("  After second operation: product = {}", x * y);
    });
    chained.accept(&5, &3);
    println!("  Final log: {:?}\n", *log.lock().unwrap());

    // 3. ArcBiConsumer - Thread-safe shared ownership
    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
        println!("  Thread {:?}: sum = {}", thread::current().id(), x + y);
    });

    let consumer1 = arc_consumer.clone();
    let consumer2 = arc_consumer.clone();

    let handle1 = thread::spawn(move || {
        let mut c = consumer1;
        c.accept(&10, &5);
    });

    let handle2 = thread::spawn(move || {
        let mut c = consumer2;
        c.accept(&20, &8);
    });

    handle1.join().unwrap();
    handle2.join().unwrap();
    println!("  Final log: {:?}\n", *log.lock().unwrap());

    // 4. RcBiConsumer - Single-threaded shared ownership
    println!("4. RcBiConsumer - Single-threaded shared ownership:");
    let log = Rc::new(RefCell::new(Vec::new()));
    let l = log.clone();
    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
        l.borrow_mut().push(*x + *y);
    });

    let mut clone1 = rc_consumer.clone();
    let mut clone2 = rc_consumer.clone();

    clone1.accept(&5, &3);
    println!("  After first use: {:?}", *log.borrow());

    clone2.accept(&7, &2);
    println!("  After second use: {:?}\n", *log.borrow());

    // 5. Working with closures directly
    println!("5. Working with closures directly:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut closure = move |x: &i32, y: &i32| {
        let sum = *x + *y;
        l.lock().unwrap().push(sum);
    };
    closure.accept(&10, &20);
    println!("  After closure: {:?}\n", *log.lock().unwrap());

    // 6. Conditional BiConsumer
    println!("6. Conditional BiConsumer:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut conditional = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);

    conditional.accept(&5, &3);
    println!("  Positive values: {:?}", *log.lock().unwrap());

    conditional.accept(&-5, &3);
    println!("  Negative value (unchanged): {:?}\n", *log.lock().unwrap());

    // 7. Conditional branch BiConsumer
    println!("7. Conditional branch BiConsumer:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let mut branch = BoxBiConsumer::new(move |x: &i32, _y: &i32| {
        l1.lock().unwrap().push(*x);
    })
    .when(|x: &i32, y: &i32| *x > *y)
    .or_else(move |_x: &i32, y: &i32| {
        l2.lock().unwrap().push(*y);
    });

    branch.accept(&15, &10);
    println!("  When x > y: {:?}", *log.lock().unwrap());

    branch.accept(&5, &10);
    println!("  When x <= y: {:?}\n", *log.lock().unwrap());

    // 8. Accumulating statistics
    println!("8. Accumulating statistics:");
    let count = Arc::new(Mutex::new(0));
    let sum = Arc::new(Mutex::new(0));
    let c = count.clone();
    let s = sum.clone();
    let mut stats_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        *c.lock().unwrap() += 1;
        *s.lock().unwrap() += x + y;
    });

    stats_consumer.accept(&5, &3);
    stats_consumer.accept(&10, &2);
    stats_consumer.accept(&7, &8);

    println!("  Count: {}", *count.lock().unwrap());
    println!("  Sum: {}\n", *sum.lock().unwrap());

    // 9. Name support
    println!("9. Name support:");
    let mut named_consumer = BoxBiConsumer::<i32, i32>::noop();
    println!("  Initial name: {:?}", named_consumer.name());

    named_consumer.set_name("sum_calculator");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}\n", named_consumer);

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

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

Gets the name of the consumer

Returns

Returns the consumer’s name, or None if not set

Examples found in repository

examples/bi_consumer_demo.rs (line 160)

fn main() {
    println!("=== BiConsumer Demo ===\n");

    // 1. BoxBiConsumer - Single ownership
    println!("1. BoxBiConsumer - Single ownership:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut box_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        println!("  Processing: x={}, y={}", x, y);
        l.lock().unwrap().push(*x + *y);
    });
    box_consumer.accept(&10, &5);
    println!("  Result log: {:?}\n", *log.lock().unwrap());

    // 2. Method chaining with BoxBiConsumer
    println!("2. BoxBiConsumer with method chaining:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let mut chained = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        l1.lock().unwrap().push(*x + *y);
        println!("  After first operation: sum = {}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock().unwrap().push(*x * *y);
        println!("  After second operation: product = {}", x * y);
    });
    chained.accept(&5, &3);
    println!("  Final log: {:?}\n", *log.lock().unwrap());

    // 3. ArcBiConsumer - Thread-safe shared ownership
    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
        println!("  Thread {:?}: sum = {}", thread::current().id(), x + y);
    });

    let consumer1 = arc_consumer.clone();
    let consumer2 = arc_consumer.clone();

    let handle1 = thread::spawn(move || {
        let mut c = consumer1;
        c.accept(&10, &5);
    });

    let handle2 = thread::spawn(move || {
        let mut c = consumer2;
        c.accept(&20, &8);
    });

    handle1.join().unwrap();
    handle2.join().unwrap();
    println!("  Final log: {:?}\n", *log.lock().unwrap());

    // 4. RcBiConsumer - Single-threaded shared ownership
    println!("4. RcBiConsumer - Single-threaded shared ownership:");
    let log = Rc::new(RefCell::new(Vec::new()));
    let l = log.clone();
    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
        l.borrow_mut().push(*x + *y);
    });

    let mut clone1 = rc_consumer.clone();
    let mut clone2 = rc_consumer.clone();

    clone1.accept(&5, &3);
    println!("  After first use: {:?}", *log.borrow());

    clone2.accept(&7, &2);
    println!("  After second use: {:?}\n", *log.borrow());

    // 5. Working with closures directly
    println!("5. Working with closures directly:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut closure = move |x: &i32, y: &i32| {
        let sum = *x + *y;
        l.lock().unwrap().push(sum);
    };
    closure.accept(&10, &20);
    println!("  After closure: {:?}\n", *log.lock().unwrap());

    // 6. Conditional BiConsumer
    println!("6. Conditional BiConsumer:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut conditional = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);

    conditional.accept(&5, &3);
    println!("  Positive values: {:?}", *log.lock().unwrap());

    conditional.accept(&-5, &3);
    println!("  Negative value (unchanged): {:?}\n", *log.lock().unwrap());

    // 7. Conditional branch BiConsumer
    println!("7. Conditional branch BiConsumer:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let mut branch = BoxBiConsumer::new(move |x: &i32, _y: &i32| {
        l1.lock().unwrap().push(*x);
    })
    .when(|x: &i32, y: &i32| *x > *y)
    .or_else(move |_x: &i32, y: &i32| {
        l2.lock().unwrap().push(*y);
    });

    branch.accept(&15, &10);
    println!("  When x > y: {:?}", *log.lock().unwrap());

    branch.accept(&5, &10);
    println!("  When x <= y: {:?}\n", *log.lock().unwrap());

    // 8. Accumulating statistics
    println!("8. Accumulating statistics:");
    let count = Arc::new(Mutex::new(0));
    let sum = Arc::new(Mutex::new(0));
    let c = count.clone();
    let s = sum.clone();
    let mut stats_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        *c.lock().unwrap() += 1;
        *s.lock().unwrap() += x + y;
    });

    stats_consumer.accept(&5, &3);
    stats_consumer.accept(&10, &2);
    stats_consumer.accept(&7, &8);

    println!("  Count: {}", *count.lock().unwrap());
    println!("  Sum: {}\n", *sum.lock().unwrap());

    // 9. Name support
    println!("9. Name support:");
    let mut named_consumer = BoxBiConsumer::<i32, i32>::noop();
    println!("  Initial name: {:?}", named_consumer.name());

    named_consumer.set_name("sum_calculator");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}\n", named_consumer);

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

pub fn set_name(&mut self, name: impl Into<String>)

Sets the name of the consumer

Parameters

• name - The name to set

Examples found in repository

examples/bi_consumer_demo.rs (line 162)

fn main() {
    println!("=== BiConsumer Demo ===\n");

    // 1. BoxBiConsumer - Single ownership
    println!("1. BoxBiConsumer - Single ownership:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut box_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        println!("  Processing: x={}, y={}", x, y);
        l.lock().unwrap().push(*x + *y);
    });
    box_consumer.accept(&10, &5);
    println!("  Result log: {:?}\n", *log.lock().unwrap());

    // 2. Method chaining with BoxBiConsumer
    println!("2. BoxBiConsumer with method chaining:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let mut chained = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        l1.lock().unwrap().push(*x + *y);
        println!("  After first operation: sum = {}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock().unwrap().push(*x * *y);
        println!("  After second operation: product = {}", x * y);
    });
    chained.accept(&5, &3);
    println!("  Final log: {:?}\n", *log.lock().unwrap());

    // 3. ArcBiConsumer - Thread-safe shared ownership
    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
        println!("  Thread {:?}: sum = {}", thread::current().id(), x + y);
    });

    let consumer1 = arc_consumer.clone();
    let consumer2 = arc_consumer.clone();

    let handle1 = thread::spawn(move || {
        let mut c = consumer1;
        c.accept(&10, &5);
    });

    let handle2 = thread::spawn(move || {
        let mut c = consumer2;
        c.accept(&20, &8);
    });

    handle1.join().unwrap();
    handle2.join().unwrap();
    println!("  Final log: {:?}\n", *log.lock().unwrap());

    // 4. RcBiConsumer - Single-threaded shared ownership
    println!("4. RcBiConsumer - Single-threaded shared ownership:");
    let log = Rc::new(RefCell::new(Vec::new()));
    let l = log.clone();
    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
        l.borrow_mut().push(*x + *y);
    });

    let mut clone1 = rc_consumer.clone();
    let mut clone2 = rc_consumer.clone();

    clone1.accept(&5, &3);
    println!("  After first use: {:?}", *log.borrow());

    clone2.accept(&7, &2);
    println!("  After second use: {:?}\n", *log.borrow());

    // 5. Working with closures directly
    println!("5. Working with closures directly:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut closure = move |x: &i32, y: &i32| {
        let sum = *x + *y;
        l.lock().unwrap().push(sum);
    };
    closure.accept(&10, &20);
    println!("  After closure: {:?}\n", *log.lock().unwrap());

    // 6. Conditional BiConsumer
    println!("6. Conditional BiConsumer:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut conditional = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);

    conditional.accept(&5, &3);
    println!("  Positive values: {:?}", *log.lock().unwrap());

    conditional.accept(&-5, &3);
    println!("  Negative value (unchanged): {:?}\n", *log.lock().unwrap());

    // 7. Conditional branch BiConsumer
    println!("7. Conditional branch BiConsumer:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let mut branch = BoxBiConsumer::new(move |x: &i32, _y: &i32| {
        l1.lock().unwrap().push(*x);
    })
    .when(|x: &i32, y: &i32| *x > *y)
    .or_else(move |_x: &i32, y: &i32| {
        l2.lock().unwrap().push(*y);
    });

    branch.accept(&15, &10);
    println!("  When x > y: {:?}", *log.lock().unwrap());

    branch.accept(&5, &10);
    println!("  When x <= y: {:?}\n", *log.lock().unwrap());

    // 8. Accumulating statistics
    println!("8. Accumulating statistics:");
    let count = Arc::new(Mutex::new(0));
    let sum = Arc::new(Mutex::new(0));
    let c = count.clone();
    let s = sum.clone();
    let mut stats_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        *c.lock().unwrap() += 1;
        *s.lock().unwrap() += x + y;
    });

    stats_consumer.accept(&5, &3);
    stats_consumer.accept(&10, &2);
    stats_consumer.accept(&7, &8);

    println!("  Count: {}", *count.lock().unwrap());
    println!("  Sum: {}\n", *sum.lock().unwrap());

    // 9. Name support
    println!("9. Name support:");
    let mut named_consumer = BoxBiConsumer::<i32, i32>::noop();
    println!("  Initial name: {:?}", named_consumer.name());

    named_consumer.set_name("sum_calculator");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}\n", named_consumer);

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

pub fn and_then<C>(self, next: C) -> Self

where C: BiConsumer<T, U> + 'static,

Chains another consumer in sequence

Returns a new consumer executing the current operation first, then the next operation. Consumes self.

Type Parameters

• C - The type of the next consumer

Parameters

• next - The consumer to execute after the current operation. Note: This parameter is passed by value and will transfer ownership. If you need to preserve the original consumer, clone it first (if it implements Clone). Can be:
  • A closure: |x: &T, y: &U|
  • A BoxBiConsumer<T, U>
  • An ArcBiConsumer<T, U>
  • An RcBiConsumer<T, U>
  • Any type implementing BiConsumer<T, U>

Returns

Returns a new composed BoxBiConsumer<T, U>

Examples

Direct value passing (ownership transfer)

use prism3_function::{BiConsumer, BoxBiConsumer};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l1 = log.clone();
let l2 = log.clone();
let first = BoxBiConsumer::new(move |x: &i32, y: &i32| {
    l1.lock().unwrap().push(*x + *y);
});
let second = BoxBiConsumer::new(move |x: &i32, y: &i32| {
    l2.lock().unwrap().push(*x * *y);
});

// second is moved here
let mut chained = first.and_then(second);
chained.accept(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![8, 15]);
// second.accept(&2, &3); // Would not compile - moved

Preserving original with clone

use prism3_function::{BiConsumer, BoxBiConsumer};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l1 = log.clone();
let l2 = log.clone();
let first = BoxBiConsumer::new(move |x: &i32, y: &i32| {
    l1.lock().unwrap().push(*x + *y);
});
let second = BoxBiConsumer::new(move |x: &i32, y: &i32| {
    l2.lock().unwrap().push(*x * *y);
});

// Clone to preserve original
let mut chained = first.and_then(second.clone());
chained.accept(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![8, 15]);

// Original still usable
second.accept(&2, &3);
assert_eq!(*log.lock().unwrap(), vec![8, 15, 6]);

Examples found in repository

examples/bi_consumer_demo.rs (lines 44-47)

fn main() {
    println!("=== BiConsumer Demo ===\n");

    // 1. BoxBiConsumer - Single ownership
    println!("1. BoxBiConsumer - Single ownership:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut box_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        println!("  Processing: x={}, y={}", x, y);
        l.lock().unwrap().push(*x + *y);
    });
    box_consumer.accept(&10, &5);
    println!("  Result log: {:?}\n", *log.lock().unwrap());

    // 2. Method chaining with BoxBiConsumer
    println!("2. BoxBiConsumer with method chaining:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let mut chained = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        l1.lock().unwrap().push(*x + *y);
        println!("  After first operation: sum = {}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock().unwrap().push(*x * *y);
        println!("  After second operation: product = {}", x * y);
    });
    chained.accept(&5, &3);
    println!("  Final log: {:?}\n", *log.lock().unwrap());

    // 3. ArcBiConsumer - Thread-safe shared ownership
    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
        println!("  Thread {:?}: sum = {}", thread::current().id(), x + y);
    });

    let consumer1 = arc_consumer.clone();
    let consumer2 = arc_consumer.clone();

    let handle1 = thread::spawn(move || {
        let mut c = consumer1;
        c.accept(&10, &5);
    });

    let handle2 = thread::spawn(move || {
        let mut c = consumer2;
        c.accept(&20, &8);
    });

    handle1.join().unwrap();
    handle2.join().unwrap();
    println!("  Final log: {:?}\n", *log.lock().unwrap());

    // 4. RcBiConsumer - Single-threaded shared ownership
    println!("4. RcBiConsumer - Single-threaded shared ownership:");
    let log = Rc::new(RefCell::new(Vec::new()));
    let l = log.clone();
    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
        l.borrow_mut().push(*x + *y);
    });

    let mut clone1 = rc_consumer.clone();
    let mut clone2 = rc_consumer.clone();

    clone1.accept(&5, &3);
    println!("  After first use: {:?}", *log.borrow());

    clone2.accept(&7, &2);
    println!("  After second use: {:?}\n", *log.borrow());

    // 5. Working with closures directly
    println!("5. Working with closures directly:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut closure = move |x: &i32, y: &i32| {
        let sum = *x + *y;
        l.lock().unwrap().push(sum);
    };
    closure.accept(&10, &20);
    println!("  After closure: {:?}\n", *log.lock().unwrap());

    // 6. Conditional BiConsumer
    println!("6. Conditional BiConsumer:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut conditional = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);

    conditional.accept(&5, &3);
    println!("  Positive values: {:?}", *log.lock().unwrap());

    conditional.accept(&-5, &3);
    println!("  Negative value (unchanged): {:?}\n", *log.lock().unwrap());

    // 7. Conditional branch BiConsumer
    println!("7. Conditional branch BiConsumer:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let mut branch = BoxBiConsumer::new(move |x: &i32, _y: &i32| {
        l1.lock().unwrap().push(*x);
    })
    .when(|x: &i32, y: &i32| *x > *y)
    .or_else(move |_x: &i32, y: &i32| {
        l2.lock().unwrap().push(*y);
    });

    branch.accept(&15, &10);
    println!("  When x > y: {:?}", *log.lock().unwrap());

    branch.accept(&5, &10);
    println!("  When x <= y: {:?}\n", *log.lock().unwrap());

    // 8. Accumulating statistics
    println!("8. Accumulating statistics:");
    let count = Arc::new(Mutex::new(0));
    let sum = Arc::new(Mutex::new(0));
    let c = count.clone();
    let s = sum.clone();
    let mut stats_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        *c.lock().unwrap() += 1;
        *s.lock().unwrap() += x + y;
    });

    stats_consumer.accept(&5, &3);
    stats_consumer.accept(&10, &2);
    stats_consumer.accept(&7, &8);

    println!("  Count: {}", *count.lock().unwrap());
    println!("  Sum: {}\n", *sum.lock().unwrap());

    // 9. Name support
    println!("9. Name support:");
    let mut named_consumer = BoxBiConsumer::<i32, i32>::noop();
    println!("  Initial name: {:?}", named_consumer.name());

    named_consumer.set_name("sum_calculator");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}\n", named_consumer);

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

pub fn when<P>(self, predicate: P) -> BoxConditionalBiConsumer<T, U>

where P: BiPredicate<T, U> + 'static,

Creates a conditional bi-consumer

Returns a bi-consumer that only executes when a predicate is satisfied.

Parameters

• predicate - The condition to check. Note: This parameter is passed by value and will transfer ownership. If you need to preserve the original bi-predicate, clone it first (if it implements Clone). Can be:
  • A closure: |x: &T, y: &U| -> bool
  • A function pointer: fn(&T, &U) -> bool
  • A BoxBiPredicate<T, U>
  • An RcBiPredicate<T, U>
  • An ArcBiPredicate<T, U>
  • Any type implementing BiPredicate<T, U>

Returns

Returns BoxConditionalBiConsumer<T, U>

Examples found in repository

examples/bi_consumer_demo.rs (line 112)

fn main() {
    println!("=== BiConsumer Demo ===\n");

    // 1. BoxBiConsumer - Single ownership
    println!("1. BoxBiConsumer - Single ownership:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut box_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        println!("  Processing: x={}, y={}", x, y);
        l.lock().unwrap().push(*x + *y);
    });
    box_consumer.accept(&10, &5);
    println!("  Result log: {:?}\n", *log.lock().unwrap());

    // 2. Method chaining with BoxBiConsumer
    println!("2. BoxBiConsumer with method chaining:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let mut chained = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        l1.lock().unwrap().push(*x + *y);
        println!("  After first operation: sum = {}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock().unwrap().push(*x * *y);
        println!("  After second operation: product = {}", x * y);
    });
    chained.accept(&5, &3);
    println!("  Final log: {:?}\n", *log.lock().unwrap());

    // 3. ArcBiConsumer - Thread-safe shared ownership
    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
        println!("  Thread {:?}: sum = {}", thread::current().id(), x + y);
    });

    let consumer1 = arc_consumer.clone();
    let consumer2 = arc_consumer.clone();

    let handle1 = thread::spawn(move || {
        let mut c = consumer1;
        c.accept(&10, &5);
    });

    let handle2 = thread::spawn(move || {
        let mut c = consumer2;
        c.accept(&20, &8);
    });

    handle1.join().unwrap();
    handle2.join().unwrap();
    println!("  Final log: {:?}\n", *log.lock().unwrap());

    // 4. RcBiConsumer - Single-threaded shared ownership
    println!("4. RcBiConsumer - Single-threaded shared ownership:");
    let log = Rc::new(RefCell::new(Vec::new()));
    let l = log.clone();
    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
        l.borrow_mut().push(*x + *y);
    });

    let mut clone1 = rc_consumer.clone();
    let mut clone2 = rc_consumer.clone();

    clone1.accept(&5, &3);
    println!("  After first use: {:?}", *log.borrow());

    clone2.accept(&7, &2);
    println!("  After second use: {:?}\n", *log.borrow());

    // 5. Working with closures directly
    println!("5. Working with closures directly:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut closure = move |x: &i32, y: &i32| {
        let sum = *x + *y;
        l.lock().unwrap().push(sum);
    };
    closure.accept(&10, &20);
    println!("  After closure: {:?}\n", *log.lock().unwrap());

    // 6. Conditional BiConsumer
    println!("6. Conditional BiConsumer:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let mut conditional = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);

    conditional.accept(&5, &3);
    println!("  Positive values: {:?}", *log.lock().unwrap());

    conditional.accept(&-5, &3);
    println!("  Negative value (unchanged): {:?}\n", *log.lock().unwrap());

    // 7. Conditional branch BiConsumer
    println!("7. Conditional branch BiConsumer:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let mut branch = BoxBiConsumer::new(move |x: &i32, _y: &i32| {
        l1.lock().unwrap().push(*x);
    })
    .when(|x: &i32, y: &i32| *x > *y)
    .or_else(move |_x: &i32, y: &i32| {
        l2.lock().unwrap().push(*y);
    });

    branch.accept(&15, &10);
    println!("  When x > y: {:?}", *log.lock().unwrap());

    branch.accept(&5, &10);
    println!("  When x <= y: {:?}\n", *log.lock().unwrap());

    // 8. Accumulating statistics
    println!("8. Accumulating statistics:");
    let count = Arc::new(Mutex::new(0));
    let sum = Arc::new(Mutex::new(0));
    let c = count.clone();
    let s = sum.clone();
    let mut stats_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        *c.lock().unwrap() += 1;
        *s.lock().unwrap() += x + y;
    });

    stats_consumer.accept(&5, &3);
    stats_consumer.accept(&10, &2);
    stats_consumer.accept(&7, &8);

    println!("  Count: {}", *count.lock().unwrap());
    println!("  Sum: {}\n", *sum.lock().unwrap());

    // 9. Name support
    println!("9. Name support:");
    let mut named_consumer = BoxBiConsumer::<i32, i32>::noop();
    println!("  Initial name: {:?}", named_consumer.name());

    named_consumer.set_name("sum_calculator");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}\n", named_consumer);

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

Trait Implementations

impl<T, U> BiConsumer<T, U> for BoxBiConsumer<T, U>

fn accept(&mut self, first: &T, second: &U)

Performs the consumption operation

fn into_box(self) -> BoxBiConsumer<T, U>

where T: 'static, U: 'static,

Converts to BoxBiConsumer

fn into_rc(self) -> RcBiConsumer<T, U>

where T: 'static, U: 'static,

Converts to RcBiConsumer

fn into_fn(self) -> impl FnMut(&T, &U)

where T: 'static, U: 'static,

Converts bi-consumer to a closure

fn into_arc(self) -> ArcBiConsumer<T, U>

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

Converts to ArcBiConsumer

impl<T, U> BiConsumerOnce<T, U> for BoxBiConsumer<T, U>

where T: 'static, U: 'static,

fn accept_once(self, first: &T, second: &U)

Performs the one-time consumption operation

Executes the underlying function once and consumes the consumer. After calling this method, the consumer is no longer available.

Parameters

• first - Reference to the first value to consume
• second - Reference to the second value to consume

Examples

use prism3_function::{BiConsumerOnce, BoxBiConsumer};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l = log.clone();
let consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
    l.lock().unwrap().push(*x + *y);
});
consumer.accept_once(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![8]);

fn into_box_once(self) -> BoxBiConsumerOnce<T, U>

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

Converts to BoxBiConsumerOnce

⚠️ Consumes self: Original consumer becomes unavailable after calling this method.

Returns

Returns the wrapped BoxBiConsumerOnce<T, U>

Examples

use prism3_function::{BiConsumerOnce, BoxBiConsumer};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l = log.clone();
let consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
    l.lock().unwrap().push(*x + *y);
});
let box_once = consumer.into_box_once();
box_once.accept_once(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![8]);

fn into_fn_once(self) -> impl FnOnce(&T, &U)

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

Converts to a closure

⚠️ Consumes self: Original consumer becomes unavailable after calling this method.

Converts the bi-consumer to a closure usable with standard library methods requiring FnOnce.

Returns

Returns a closure implementing FnOnce(&T, &U)

Examples

use prism3_function::{BiConsumerOnce, BoxBiConsumer};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l = log.clone();
let consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
    l.lock().unwrap().push(*x + *y);
});
let func = consumer.into_fn_once();
func(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![8]);

impl<T, U> Debug for BoxBiConsumer<T, U>

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

Formats the value using the given formatter.

impl<T, U> Display for BoxBiConsumer<T, U>

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

Formats the value using the given formatter.