Struct BoxBiConsumer 

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

BoxBiConsumer struct

A non-mutating bi-consumer implementation based on Box<dyn Fn(&T, &U)> for single ownership scenarios.

Features

• Single Ownership: Not cloneable, ownership moves on use
• Zero Overhead: No reference counting or locking
• Shared-reference API: Invoked through &self and shared input references
• No Wrapper Interior Mutability: No need for Mutex or RefCell in the wrapper

Use Cases

Choose BoxBiConsumer when:

• The non-mutating bi-consumer is used only once or in a linear flow
• No need to share the consumer across contexts
• Pure observation operations like logging

Examples

use qubit_function::{BiConsumer, BoxBiConsumer};

let consumer = BoxBiConsumer::new(|x: &i32, y: &i32| {
    println!("Sum: {}", x + y);
});
consumer.accept(&5, &3);

Implementations

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

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

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

Creates a new bi-consumer.

Wraps the provided closure in the appropriate smart pointer type for this bi-consumer implementation.

Examples found in repository

examples/consumers/bi_consumer_observation_demo.rs (lines 35-37)

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

    // 1. BoxBiConsumer - Single ownership
    println!("1. BoxBiConsumer - Single ownership:");
    let box_consumer = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  Values: x={}, y={}, sum={}", x, y, x + y);
    });
    box_consumer.accept(&10, &5);
    println!();

    // 2. Method chaining with BoxBiConsumer
    println!("2. BoxBiConsumer with method chaining:");
    let chained = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  First operation: x={}, y={}", x, y);
    })
    .and_then(|x: &i32, y: &i32| {
        println!("  Second operation: sum={}", x + y);
    })
    .and_then(|x: &i32, y: &i32| {
        println!("  Third operation: product={}", x * y);
    });
    chained.accept(&5, &3);
    println!();

    // 3. ArcBiConsumer - Thread-safe shared ownership
    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
    let counter = Arc::new(AtomicUsize::new(0));
    let c = counter.clone();
    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
        c.fetch_add(1, Ordering::SeqCst);
        println!("  Thread {:?}: sum={}", thread::current().id(), x + y);
    });

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

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

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

    handle1.join().expect("thread should not panic");
    handle2.join().expect("thread should not panic");
    println!("  Total calls: {}\n", counter.load(Ordering::SeqCst));

    // 4. RcBiConsumer - Single-threaded shared ownership
    println!("4. RcBiConsumer - Single-threaded shared ownership:");
    let counter = Rc::new(std::cell::Cell::new(0));
    let c = counter.clone();
    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
        c.set(c.get() + 1);
        println!("  Call {}: sum={}", c.get(), x + y);
    });

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

    clone1.accept(&5, &3);
    clone2.accept(&7, &2);
    println!("  Total calls: {}\n", counter.get());

    // 5. Working with closures directly
    println!("5. Working with closures directly:");
    let closure = |x: &i32, y: &i32| {
        println!("  x={}, y={}, product={}", x, y, x * y);
    };
    closure.accept(&10, &20);
    println!();

    // 6. Pure observation - logging
    println!("6. Pure observation - logging:");
    let logger = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [LOG] Processing pair: ({}, {})", x, y);
    });
    logger.accept(&5, &3);
    logger.accept(&10, &7);
    println!();

    // 7. Chaining observations
    println!("7. Chaining observations:");
    let log_input = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [INPUT] x={}, y={}", x, y);
    });
    let log_sum = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [SUM] {}", x + y);
    });
    let log_product = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [PRODUCT] {}", x * y);
    });

    let chained = log_input.and_then(log_sum).and_then(log_product);
    chained.accept(&5, &3);
    println!();

    // 8. ArcBiConsumer - Reusability
    println!("8. ArcBiConsumer - Reusability:");
    let first = ArcBiConsumer::new(|x: &i32, y: &i32| {
        println!("  First: x={}, y={}", x, y);
    });
    let second = ArcBiConsumer::new(|x: &i32, y: &i32| {
        println!("  Second: sum={}", x + y);
    });

    // Both first and second can be reused after chaining
    let chained1 = first.and_then(second.clone());
    let chained2 = first.and_then(second.clone());

    println!("  Using chained1:");
    chained1.accept(&5, &3);

    println!("  Using chained2:");
    chained2.accept(&10, &2);
    println!();

    // 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_logger");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}\n", named_consumer);

    // 10. No-op consumer
    println!("10. No-op consumer:");
    let noop = BoxBiConsumer::<i32, i32>::noop();
    noop.accept(&42, &10);
    println!("  No-op completed (no output expected)\n");

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

examples/consumers/bi_consumer_demo.rs (lines 39-42)

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 box_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        println!("  Processing: x={}, y={}", x, y);
        l.lock().expect("mutex should not be poisoned").push(*x + *y);
    });
    box_consumer.accept(&10, &5);
    println!(
        "  Result log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 chained = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        l1.lock().expect("mutex should not be poisoned").push(*x + *y);
        println!("  After first operation: sum = {}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock().expect("mutex should not be poisoned").push(*x * *y);
        println!("  After second operation: product = {}", x * y);
    });
    chained.accept(&5, &3);
    println!(
        "  Final log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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().expect("mutex should not be poisoned").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 c = consumer1;
        c.accept(&10, &5);
    });

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

    handle1.join().expect("thread should not panic");
    handle2.join().expect("thread should not panic");
    println!(
        "  Final log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 clone1 = rc_consumer.clone();
    let 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 closure = move |x: &i32, y: &i32| {
        let sum = *x + *y;
        l.lock().expect("mutex should not be poisoned").push(sum);
    };
    closure.accept(&10, &20);
    println!(
        "  After closure: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

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

    conditional.accept(&5, &3);
    println!(
        "  Positive values: {:?}",
        *log.lock().expect("mutex should not be poisoned")
    );

    conditional.accept(&-5, &3);
    println!(
        "  Negative value (unchanged): {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 = BoxStatefulBiConsumer::new(move |x: &i32, _y: &i32| {
        l1.lock().expect("mutex should not be poisoned").push(*x);
    })
    .when(|x: &i32, y: &i32| *x > *y)
    .or_else(move |_x: &i32, y: &i32| {
        l2.lock().expect("mutex should not be poisoned").push(*y);
    });

    branch.accept(&15, &10);
    println!("  When x > y: {:?}", *log.lock().expect("mutex should not be poisoned"));

    branch.accept(&5, &10);
    println!(
        "  When x <= y: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 stats_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        *c.lock().expect("mutex should not be poisoned") += 1;
        *s.lock().expect("mutex should not be poisoned") += x + y;
    });

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

    println!("  Count: {}", *count.lock().expect("mutex should not be poisoned"));
    println!("  Sum: {}\n", *sum.lock().expect("mutex should not be poisoned"));

    // 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: Fn(&T, &U) + 'static,

Creates a new named bi-consumer.

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, &U) + 'static,

Creates a new named bi-consumer 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 bi-consumer.

Returns

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

Examples found in repository

examples/consumers/bi_consumer_observation_demo.rs (line 151)

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

    // 1. BoxBiConsumer - Single ownership
    println!("1. BoxBiConsumer - Single ownership:");
    let box_consumer = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  Values: x={}, y={}, sum={}", x, y, x + y);
    });
    box_consumer.accept(&10, &5);
    println!();

    // 2. Method chaining with BoxBiConsumer
    println!("2. BoxBiConsumer with method chaining:");
    let chained = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  First operation: x={}, y={}", x, y);
    })
    .and_then(|x: &i32, y: &i32| {
        println!("  Second operation: sum={}", x + y);
    })
    .and_then(|x: &i32, y: &i32| {
        println!("  Third operation: product={}", x * y);
    });
    chained.accept(&5, &3);
    println!();

    // 3. ArcBiConsumer - Thread-safe shared ownership
    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
    let counter = Arc::new(AtomicUsize::new(0));
    let c = counter.clone();
    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
        c.fetch_add(1, Ordering::SeqCst);
        println!("  Thread {:?}: sum={}", thread::current().id(), x + y);
    });

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

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

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

    handle1.join().expect("thread should not panic");
    handle2.join().expect("thread should not panic");
    println!("  Total calls: {}\n", counter.load(Ordering::SeqCst));

    // 4. RcBiConsumer - Single-threaded shared ownership
    println!("4. RcBiConsumer - Single-threaded shared ownership:");
    let counter = Rc::new(std::cell::Cell::new(0));
    let c = counter.clone();
    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
        c.set(c.get() + 1);
        println!("  Call {}: sum={}", c.get(), x + y);
    });

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

    clone1.accept(&5, &3);
    clone2.accept(&7, &2);
    println!("  Total calls: {}\n", counter.get());

    // 5. Working with closures directly
    println!("5. Working with closures directly:");
    let closure = |x: &i32, y: &i32| {
        println!("  x={}, y={}, product={}", x, y, x * y);
    };
    closure.accept(&10, &20);
    println!();

    // 6. Pure observation - logging
    println!("6. Pure observation - logging:");
    let logger = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [LOG] Processing pair: ({}, {})", x, y);
    });
    logger.accept(&5, &3);
    logger.accept(&10, &7);
    println!();

    // 7. Chaining observations
    println!("7. Chaining observations:");
    let log_input = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [INPUT] x={}, y={}", x, y);
    });
    let log_sum = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [SUM] {}", x + y);
    });
    let log_product = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [PRODUCT] {}", x * y);
    });

    let chained = log_input.and_then(log_sum).and_then(log_product);
    chained.accept(&5, &3);
    println!();

    // 8. ArcBiConsumer - Reusability
    println!("8. ArcBiConsumer - Reusability:");
    let first = ArcBiConsumer::new(|x: &i32, y: &i32| {
        println!("  First: x={}, y={}", x, y);
    });
    let second = ArcBiConsumer::new(|x: &i32, y: &i32| {
        println!("  Second: sum={}", x + y);
    });

    // Both first and second can be reused after chaining
    let chained1 = first.and_then(second.clone());
    let chained2 = first.and_then(second.clone());

    println!("  Using chained1:");
    chained1.accept(&5, &3);

    println!("  Using chained2:");
    chained2.accept(&10, &2);
    println!();

    // 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_logger");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}\n", named_consumer);

    // 10. No-op consumer
    println!("10. No-op consumer:");
    let noop = BoxBiConsumer::<i32, i32>::noop();
    noop.accept(&42, &10);
    println!("  No-op completed (no output expected)\n");

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

examples/consumers/bi_consumer_demo.rs (line 192)

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 box_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        println!("  Processing: x={}, y={}", x, y);
        l.lock().expect("mutex should not be poisoned").push(*x + *y);
    });
    box_consumer.accept(&10, &5);
    println!(
        "  Result log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 chained = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        l1.lock().expect("mutex should not be poisoned").push(*x + *y);
        println!("  After first operation: sum = {}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock().expect("mutex should not be poisoned").push(*x * *y);
        println!("  After second operation: product = {}", x * y);
    });
    chained.accept(&5, &3);
    println!(
        "  Final log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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().expect("mutex should not be poisoned").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 c = consumer1;
        c.accept(&10, &5);
    });

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

    handle1.join().expect("thread should not panic");
    handle2.join().expect("thread should not panic");
    println!(
        "  Final log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 clone1 = rc_consumer.clone();
    let 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 closure = move |x: &i32, y: &i32| {
        let sum = *x + *y;
        l.lock().expect("mutex should not be poisoned").push(sum);
    };
    closure.accept(&10, &20);
    println!(
        "  After closure: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

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

    conditional.accept(&5, &3);
    println!(
        "  Positive values: {:?}",
        *log.lock().expect("mutex should not be poisoned")
    );

    conditional.accept(&-5, &3);
    println!(
        "  Negative value (unchanged): {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 = BoxStatefulBiConsumer::new(move |x: &i32, _y: &i32| {
        l1.lock().expect("mutex should not be poisoned").push(*x);
    })
    .when(|x: &i32, y: &i32| *x > *y)
    .or_else(move |_x: &i32, y: &i32| {
        l2.lock().expect("mutex should not be poisoned").push(*y);
    });

    branch.accept(&15, &10);
    println!("  When x > y: {:?}", *log.lock().expect("mutex should not be poisoned"));

    branch.accept(&5, &10);
    println!(
        "  When x <= y: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 stats_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        *c.lock().expect("mutex should not be poisoned") += 1;
        *s.lock().expect("mutex should not be poisoned") += x + y;
    });

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

    println!("  Count: {}", *count.lock().expect("mutex should not be poisoned"));
    println!("  Sum: {}\n", *sum.lock().expect("mutex should not be poisoned"));

    // 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: &str)

Sets the name of this bi-consumer.

Parameters

• name - The name to set for this bi-consumer

Examples found in repository

examples/consumers/bi_consumer_observation_demo.rs (line 153)

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

    // 1. BoxBiConsumer - Single ownership
    println!("1. BoxBiConsumer - Single ownership:");
    let box_consumer = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  Values: x={}, y={}, sum={}", x, y, x + y);
    });
    box_consumer.accept(&10, &5);
    println!();

    // 2. Method chaining with BoxBiConsumer
    println!("2. BoxBiConsumer with method chaining:");
    let chained = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  First operation: x={}, y={}", x, y);
    })
    .and_then(|x: &i32, y: &i32| {
        println!("  Second operation: sum={}", x + y);
    })
    .and_then(|x: &i32, y: &i32| {
        println!("  Third operation: product={}", x * y);
    });
    chained.accept(&5, &3);
    println!();

    // 3. ArcBiConsumer - Thread-safe shared ownership
    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
    let counter = Arc::new(AtomicUsize::new(0));
    let c = counter.clone();
    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
        c.fetch_add(1, Ordering::SeqCst);
        println!("  Thread {:?}: sum={}", thread::current().id(), x + y);
    });

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

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

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

    handle1.join().expect("thread should not panic");
    handle2.join().expect("thread should not panic");
    println!("  Total calls: {}\n", counter.load(Ordering::SeqCst));

    // 4. RcBiConsumer - Single-threaded shared ownership
    println!("4. RcBiConsumer - Single-threaded shared ownership:");
    let counter = Rc::new(std::cell::Cell::new(0));
    let c = counter.clone();
    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
        c.set(c.get() + 1);
        println!("  Call {}: sum={}", c.get(), x + y);
    });

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

    clone1.accept(&5, &3);
    clone2.accept(&7, &2);
    println!("  Total calls: {}\n", counter.get());

    // 5. Working with closures directly
    println!("5. Working with closures directly:");
    let closure = |x: &i32, y: &i32| {
        println!("  x={}, y={}, product={}", x, y, x * y);
    };
    closure.accept(&10, &20);
    println!();

    // 6. Pure observation - logging
    println!("6. Pure observation - logging:");
    let logger = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [LOG] Processing pair: ({}, {})", x, y);
    });
    logger.accept(&5, &3);
    logger.accept(&10, &7);
    println!();

    // 7. Chaining observations
    println!("7. Chaining observations:");
    let log_input = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [INPUT] x={}, y={}", x, y);
    });
    let log_sum = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [SUM] {}", x + y);
    });
    let log_product = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [PRODUCT] {}", x * y);
    });

    let chained = log_input.and_then(log_sum).and_then(log_product);
    chained.accept(&5, &3);
    println!();

    // 8. ArcBiConsumer - Reusability
    println!("8. ArcBiConsumer - Reusability:");
    let first = ArcBiConsumer::new(|x: &i32, y: &i32| {
        println!("  First: x={}, y={}", x, y);
    });
    let second = ArcBiConsumer::new(|x: &i32, y: &i32| {
        println!("  Second: sum={}", x + y);
    });

    // Both first and second can be reused after chaining
    let chained1 = first.and_then(second.clone());
    let chained2 = first.and_then(second.clone());

    println!("  Using chained1:");
    chained1.accept(&5, &3);

    println!("  Using chained2:");
    chained2.accept(&10, &2);
    println!();

    // 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_logger");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}\n", named_consumer);

    // 10. No-op consumer
    println!("10. No-op consumer:");
    let noop = BoxBiConsumer::<i32, i32>::noop();
    noop.accept(&42, &10);
    println!("  No-op completed (no output expected)\n");

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

examples/consumers/bi_consumer_demo.rs (line 194)

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 box_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        println!("  Processing: x={}, y={}", x, y);
        l.lock().expect("mutex should not be poisoned").push(*x + *y);
    });
    box_consumer.accept(&10, &5);
    println!(
        "  Result log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 chained = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        l1.lock().expect("mutex should not be poisoned").push(*x + *y);
        println!("  After first operation: sum = {}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock().expect("mutex should not be poisoned").push(*x * *y);
        println!("  After second operation: product = {}", x * y);
    });
    chained.accept(&5, &3);
    println!(
        "  Final log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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().expect("mutex should not be poisoned").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 c = consumer1;
        c.accept(&10, &5);
    });

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

    handle1.join().expect("thread should not panic");
    handle2.join().expect("thread should not panic");
    println!(
        "  Final log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 clone1 = rc_consumer.clone();
    let 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 closure = move |x: &i32, y: &i32| {
        let sum = *x + *y;
        l.lock().expect("mutex should not be poisoned").push(sum);
    };
    closure.accept(&10, &20);
    println!(
        "  After closure: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

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

    conditional.accept(&5, &3);
    println!(
        "  Positive values: {:?}",
        *log.lock().expect("mutex should not be poisoned")
    );

    conditional.accept(&-5, &3);
    println!(
        "  Negative value (unchanged): {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 = BoxStatefulBiConsumer::new(move |x: &i32, _y: &i32| {
        l1.lock().expect("mutex should not be poisoned").push(*x);
    })
    .when(|x: &i32, y: &i32| *x > *y)
    .or_else(move |_x: &i32, y: &i32| {
        l2.lock().expect("mutex should not be poisoned").push(*y);
    });

    branch.accept(&15, &10);
    println!("  When x > y: {:?}", *log.lock().expect("mutex should not be poisoned"));

    branch.accept(&5, &10);
    println!(
        "  When x <= y: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 stats_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        *c.lock().expect("mutex should not be poisoned") += 1;
        *s.lock().expect("mutex should not be poisoned") += x + y;
    });

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

    println!("  Count: {}", *count.lock().expect("mutex should not be poisoned"));
    println!("  Sum: {}\n", *sum.lock().expect("mutex should not be poisoned"));

    // 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 clear_name(&mut self)

Clears the name of this bi-consumer.

pub fn noop() -> Self

Creates a no-operation bi-consumer.

Creates a bi-consumer that does nothing when called. Useful for default values or placeholder implementations.

Returns

Returns a new bi-consumer instance that performs no operation.

Examples found in repository

examples/consumers/bi_consumer_observation_demo.rs (line 150)

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

    // 1. BoxBiConsumer - Single ownership
    println!("1. BoxBiConsumer - Single ownership:");
    let box_consumer = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  Values: x={}, y={}, sum={}", x, y, x + y);
    });
    box_consumer.accept(&10, &5);
    println!();

    // 2. Method chaining with BoxBiConsumer
    println!("2. BoxBiConsumer with method chaining:");
    let chained = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  First operation: x={}, y={}", x, y);
    })
    .and_then(|x: &i32, y: &i32| {
        println!("  Second operation: sum={}", x + y);
    })
    .and_then(|x: &i32, y: &i32| {
        println!("  Third operation: product={}", x * y);
    });
    chained.accept(&5, &3);
    println!();

    // 3. ArcBiConsumer - Thread-safe shared ownership
    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
    let counter = Arc::new(AtomicUsize::new(0));
    let c = counter.clone();
    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
        c.fetch_add(1, Ordering::SeqCst);
        println!("  Thread {:?}: sum={}", thread::current().id(), x + y);
    });

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

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

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

    handle1.join().expect("thread should not panic");
    handle2.join().expect("thread should not panic");
    println!("  Total calls: {}\n", counter.load(Ordering::SeqCst));

    // 4. RcBiConsumer - Single-threaded shared ownership
    println!("4. RcBiConsumer - Single-threaded shared ownership:");
    let counter = Rc::new(std::cell::Cell::new(0));
    let c = counter.clone();
    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
        c.set(c.get() + 1);
        println!("  Call {}: sum={}", c.get(), x + y);
    });

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

    clone1.accept(&5, &3);
    clone2.accept(&7, &2);
    println!("  Total calls: {}\n", counter.get());

    // 5. Working with closures directly
    println!("5. Working with closures directly:");
    let closure = |x: &i32, y: &i32| {
        println!("  x={}, y={}, product={}", x, y, x * y);
    };
    closure.accept(&10, &20);
    println!();

    // 6. Pure observation - logging
    println!("6. Pure observation - logging:");
    let logger = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [LOG] Processing pair: ({}, {})", x, y);
    });
    logger.accept(&5, &3);
    logger.accept(&10, &7);
    println!();

    // 7. Chaining observations
    println!("7. Chaining observations:");
    let log_input = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [INPUT] x={}, y={}", x, y);
    });
    let log_sum = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [SUM] {}", x + y);
    });
    let log_product = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [PRODUCT] {}", x * y);
    });

    let chained = log_input.and_then(log_sum).and_then(log_product);
    chained.accept(&5, &3);
    println!();

    // 8. ArcBiConsumer - Reusability
    println!("8. ArcBiConsumer - Reusability:");
    let first = ArcBiConsumer::new(|x: &i32, y: &i32| {
        println!("  First: x={}, y={}", x, y);
    });
    let second = ArcBiConsumer::new(|x: &i32, y: &i32| {
        println!("  Second: sum={}", x + y);
    });

    // Both first and second can be reused after chaining
    let chained1 = first.and_then(second.clone());
    let chained2 = first.and_then(second.clone());

    println!("  Using chained1:");
    chained1.accept(&5, &3);

    println!("  Using chained2:");
    chained2.accept(&10, &2);
    println!();

    // 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_logger");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}\n", named_consumer);

    // 10. No-op consumer
    println!("10. No-op consumer:");
    let noop = BoxBiConsumer::<i32, i32>::noop();
    noop.accept(&42, &10);
    println!("  No-op completed (no output expected)\n");

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

examples/consumers/bi_consumer_demo.rs (line 191)

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 box_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        println!("  Processing: x={}, y={}", x, y);
        l.lock().expect("mutex should not be poisoned").push(*x + *y);
    });
    box_consumer.accept(&10, &5);
    println!(
        "  Result log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 chained = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        l1.lock().expect("mutex should not be poisoned").push(*x + *y);
        println!("  After first operation: sum = {}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock().expect("mutex should not be poisoned").push(*x * *y);
        println!("  After second operation: product = {}", x * y);
    });
    chained.accept(&5, &3);
    println!(
        "  Final log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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().expect("mutex should not be poisoned").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 c = consumer1;
        c.accept(&10, &5);
    });

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

    handle1.join().expect("thread should not panic");
    handle2.join().expect("thread should not panic");
    println!(
        "  Final log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 clone1 = rc_consumer.clone();
    let 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 closure = move |x: &i32, y: &i32| {
        let sum = *x + *y;
        l.lock().expect("mutex should not be poisoned").push(sum);
    };
    closure.accept(&10, &20);
    println!(
        "  After closure: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

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

    conditional.accept(&5, &3);
    println!(
        "  Positive values: {:?}",
        *log.lock().expect("mutex should not be poisoned")
    );

    conditional.accept(&-5, &3);
    println!(
        "  Negative value (unchanged): {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 = BoxStatefulBiConsumer::new(move |x: &i32, _y: &i32| {
        l1.lock().expect("mutex should not be poisoned").push(*x);
    })
    .when(|x: &i32, y: &i32| *x > *y)
    .or_else(move |_x: &i32, y: &i32| {
        l2.lock().expect("mutex should not be poisoned").push(*y);
    });

    branch.accept(&15, &10);
    println!("  When x > y: {:?}", *log.lock().expect("mutex should not be poisoned"));

    branch.accept(&5, &10);
    println!(
        "  When x <= y: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 stats_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        *c.lock().expect("mutex should not be poisoned") += 1;
        *s.lock().expect("mutex should not be poisoned") += x + y;
    });

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

    println!("  Count: {}", *count.lock().expect("mutex should not be poisoned"));
    println!("  Sum: {}\n", *sum.lock().expect("mutex should not be poisoned"));

    // 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 T: 'static, U: 'static, P: BiPredicate<T, U> + 'static,

Creates a conditional two-parameter consumer that executes based on bi-predicate result.

Parameters

• predicate - The bi-predicate to determine whether to execute the consumption operation

Returns

Returns a conditional two-parameter consumer that only executes when the predicate returns true.

Examples

use std::sync::Arc;
use std::sync::atomic::{AtomicI32, Ordering};
use qubit_function::consumers::*;

let counter = Arc::new(AtomicI32::new(0));
let bi_consumer = BoxBiConsumer::new({
    let counter = Arc::clone(&counter);
    move |key: &String, value: &i32| {
        if key == "increment" {
            counter.fetch_add(*value, Ordering::SeqCst);
        }
    }
});

let conditional = bi_consumer.when(|key: &String, value: &i32| *value > 0);
conditional.accept(&"increment".to_string(), &5);  // counter = 5
conditional.accept(&"increment".to_string(), &-2); // not executed

pub fn and_then<C>(self, after: C) -> BoxBiConsumer<T, U>

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

Chains execution with another two-parameter consumer, executing the current consumer first, then the subsequent consumer.

Parameters

• after - The subsequent two-parameter consumer to execute after the current consumer completes

Returns

Returns a new two-parameter consumer that executes the current consumer and the subsequent consumer in sequence.

Examples

use std::sync::Arc;
use std::sync::atomic::{AtomicI32, Ordering};
use qubit_function::consumers::*;

let counter1 = Arc::new(AtomicI32::new(0));
let counter2 = Arc::new(AtomicI32::new(0));

let bi_consumer1 = BoxBiConsumer::new({
    let counter = Arc::clone(&counter1);
    move |key: &String, value: &i32| {
        counter.fetch_add(*value, Ordering::SeqCst);
    }
});

let bi_consumer2 = BoxBiConsumer::new({
    let counter = Arc::clone(&counter2);
    move |key: &String, value: &i32| {
        counter.fetch_add(*value * 2, Ordering::SeqCst);
    }
});

let chained = bi_consumer1.and_then(bi_consumer2);
chained.accept(&"test".to_string(), &3);
// counter1 = 3, counter2 = 6

Examples found in repository

examples/consumers/bi_consumer_observation_demo.rs (lines 46-48)

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

    // 1. BoxBiConsumer - Single ownership
    println!("1. BoxBiConsumer - Single ownership:");
    let box_consumer = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  Values: x={}, y={}, sum={}", x, y, x + y);
    });
    box_consumer.accept(&10, &5);
    println!();

    // 2. Method chaining with BoxBiConsumer
    println!("2. BoxBiConsumer with method chaining:");
    let chained = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  First operation: x={}, y={}", x, y);
    })
    .and_then(|x: &i32, y: &i32| {
        println!("  Second operation: sum={}", x + y);
    })
    .and_then(|x: &i32, y: &i32| {
        println!("  Third operation: product={}", x * y);
    });
    chained.accept(&5, &3);
    println!();

    // 3. ArcBiConsumer - Thread-safe shared ownership
    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
    let counter = Arc::new(AtomicUsize::new(0));
    let c = counter.clone();
    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
        c.fetch_add(1, Ordering::SeqCst);
        println!("  Thread {:?}: sum={}", thread::current().id(), x + y);
    });

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

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

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

    handle1.join().expect("thread should not panic");
    handle2.join().expect("thread should not panic");
    println!("  Total calls: {}\n", counter.load(Ordering::SeqCst));

    // 4. RcBiConsumer - Single-threaded shared ownership
    println!("4. RcBiConsumer - Single-threaded shared ownership:");
    let counter = Rc::new(std::cell::Cell::new(0));
    let c = counter.clone();
    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
        c.set(c.get() + 1);
        println!("  Call {}: sum={}", c.get(), x + y);
    });

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

    clone1.accept(&5, &3);
    clone2.accept(&7, &2);
    println!("  Total calls: {}\n", counter.get());

    // 5. Working with closures directly
    println!("5. Working with closures directly:");
    let closure = |x: &i32, y: &i32| {
        println!("  x={}, y={}, product={}", x, y, x * y);
    };
    closure.accept(&10, &20);
    println!();

    // 6. Pure observation - logging
    println!("6. Pure observation - logging:");
    let logger = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [LOG] Processing pair: ({}, {})", x, y);
    });
    logger.accept(&5, &3);
    logger.accept(&10, &7);
    println!();

    // 7. Chaining observations
    println!("7. Chaining observations:");
    let log_input = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [INPUT] x={}, y={}", x, y);
    });
    let log_sum = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [SUM] {}", x + y);
    });
    let log_product = BoxBiConsumer::new(|x: &i32, y: &i32| {
        println!("  [PRODUCT] {}", x * y);
    });

    let chained = log_input.and_then(log_sum).and_then(log_product);
    chained.accept(&5, &3);
    println!();

    // 8. ArcBiConsumer - Reusability
    println!("8. ArcBiConsumer - Reusability:");
    let first = ArcBiConsumer::new(|x: &i32, y: &i32| {
        println!("  First: x={}, y={}", x, y);
    });
    let second = ArcBiConsumer::new(|x: &i32, y: &i32| {
        println!("  Second: sum={}", x + y);
    });

    // Both first and second can be reused after chaining
    let chained1 = first.and_then(second.clone());
    let chained2 = first.and_then(second.clone());

    println!("  Using chained1:");
    chained1.accept(&5, &3);

    println!("  Using chained2:");
    chained2.accept(&10, &2);
    println!();

    // 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_logger");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}\n", named_consumer);

    // 10. No-op consumer
    println!("10. No-op consumer:");
    let noop = BoxBiConsumer::<i32, i32>::noop();
    noop.accept(&42, &10);
    println!("  No-op completed (no output expected)\n");

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

examples/consumers/bi_consumer_demo.rs (lines 58-61)

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 box_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        println!("  Processing: x={}, y={}", x, y);
        l.lock().expect("mutex should not be poisoned").push(*x + *y);
    });
    box_consumer.accept(&10, &5);
    println!(
        "  Result log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 chained = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        l1.lock().expect("mutex should not be poisoned").push(*x + *y);
        println!("  After first operation: sum = {}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock().expect("mutex should not be poisoned").push(*x * *y);
        println!("  After second operation: product = {}", x * y);
    });
    chained.accept(&5, &3);
    println!(
        "  Final log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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().expect("mutex should not be poisoned").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 c = consumer1;
        c.accept(&10, &5);
    });

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

    handle1.join().expect("thread should not panic");
    handle2.join().expect("thread should not panic");
    println!(
        "  Final log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 clone1 = rc_consumer.clone();
    let 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 closure = move |x: &i32, y: &i32| {
        let sum = *x + *y;
        l.lock().expect("mutex should not be poisoned").push(sum);
    };
    closure.accept(&10, &20);
    println!(
        "  After closure: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

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

    conditional.accept(&5, &3);
    println!(
        "  Positive values: {:?}",
        *log.lock().expect("mutex should not be poisoned")
    );

    conditional.accept(&-5, &3);
    println!(
        "  Negative value (unchanged): {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 = BoxStatefulBiConsumer::new(move |x: &i32, _y: &i32| {
        l1.lock().expect("mutex should not be poisoned").push(*x);
    })
    .when(|x: &i32, y: &i32| *x > *y)
    .or_else(move |_x: &i32, y: &i32| {
        l2.lock().expect("mutex should not be poisoned").push(*y);
    });

    branch.accept(&15, &10);
    println!("  When x > y: {:?}", *log.lock().expect("mutex should not be poisoned"));

    branch.accept(&5, &10);
    println!(
        "  When x <= y: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 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 stats_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
        *c.lock().expect("mutex should not be poisoned") += 1;
        *s.lock().expect("mutex should not be poisoned") += x + y;
    });

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

    println!("  Count: {}", *count.lock().expect("mutex should not be poisoned"));
    println!("  Sum: {}\n", *sum.lock().expect("mutex should not be poisoned"));

    // 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(&self, first: &T, second: &U)

Performs the non-mutating consumption operation

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

Converts to BoxBiConsumer

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

where Self: 'static,

Converts to RcBiConsumer

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

Converts non-mutating bi-consumer to a closure

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

where Self: 'static,

Convert to BiConsumerOnce

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

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

Converts to ArcBiConsumer

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.