Struct BoxBiConsumerOnce 

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

BoxBiConsumerOnce struct

A one-time bi-consumer implementation based on Box<dyn FnOnce(&T, &U)> for single ownership scenarios. This is the simplest one-time bi-consumer type for truly one-time use.

Features

• Single Ownership: Not cloneable, ownership moves on use
• Zero Overhead: No reference counting or locking
• One-Time Use: Consumes self on first call
• Builder Pattern: Method chaining consumes self naturally

Use Cases

Choose BoxBiConsumerOnce when:

• The bi-consumer is truly used only once
• Building pipelines where ownership naturally flows
• The consumer captures values that should be consumed
• Performance is critical and sharing overhead is unacceptable

Performance

BoxBiConsumerOnce has the best performance:

• 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::{BiConsumerOnce, BoxBiConsumerOnce};

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

Author

Haixing Hu

Implementations

impl<T, U> BoxBiConsumerOnce<T, U>

where T: 'static, U: 'static,

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

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

Creates a new BoxBiConsumerOnce

Type Parameters

• F - The closure type

Parameters

• f - The closure to wrap

Returns

Returns a new BoxBiConsumerOnce<T, U> instance

Examples

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

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

Examples found in repository

examples/bi_consumer_once_demo.rs (lines 25-28)

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

    // 1. Basic usage
    println!("1. Basic usage:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
        println!("  Sum: {}", x + y);
    });
    consumer.accept_once(&10, &5);
    println!("  Log: {:?}\n", *log.lock().unwrap());

    // 2. Method chaining
    println!("2. Method chaining:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let chained = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l1.lock().unwrap().push(*x + *y);
        println!("  First: sum={}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock().unwrap().push(*x * *y);
        println!("  Second: product={}", x * y);
    });
    chained.accept_once(&5, &3);
    println!("  Log: {:?}\n", *log.lock().unwrap());

    // 3. Conditional execution - true case
    println!("3. Conditional execution - true case:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let conditional = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
    conditional.accept_once(&5, &3);
    println!("  Positive values: {:?}\n", *log.lock().unwrap());

    // 4. Conditional execution - false case
    println!("4. Conditional execution - false case:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let conditional = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
    conditional.accept_once(&-5, &3);
    println!("  Negative value (unchanged): {:?}\n", *log.lock().unwrap());

    // 5. Conditional branching
    println!("5. Conditional branching:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let branch = BoxBiConsumerOnce::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_once(&15, &10);
    println!("  When x > y: {:?}\n", *log.lock().unwrap());

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

    // 7. Moving captured values
    println!("7. Moving captured values:");
    let data = vec![1, 2, 3, 4, 5];
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        println!("  x={}, y={}", x, y);
        println!("  Captured data: {:?}", data);
        println!("  Data sum: {}", data.iter().sum::<i32>());
    });
    consumer.accept_once(&5, &3);
    // data is no longer available here
    println!();

    // 8. Initialization callback
    println!("8. Initialization callback:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let init_callback = BoxBiConsumerOnce::new(move |width: &i32, height: &i32| {
        println!("  Initializing with dimensions: {}x{}", width, height);
        l.lock().unwrap().push(*width * *height);
    });
    init_callback.accept_once(&800, &600);
    println!("  Areas: {:?}\n", *log.lock().unwrap());

    // 9. Cleanup callback
    println!("9. Cleanup callback:");
    let cleanup = BoxBiConsumerOnce::new(|count: &i32, total: &i32| {
        println!("  Cleanup: processed {} out of {} items", count, total);
        println!(
            "  Success rate: {:.1}%",
            (*count as f64 / *total as f64) * 100.0
        );
    });
    cleanup.accept_once(&85, &100);
    println!();

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

    named_consumer.set_name("init_callback");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}", named_consumer);
    named_consumer.accept_once(&1, &2);
    println!();

    // 11. Print helpers
    println!("11. Print helpers:");
    let print = BoxBiConsumerOnce::new(|x: &i32, y: &i32| println!("{}, {}", x, y));
    print.accept_once(&42, &10);

    let print_with =
        BoxBiConsumerOnce::new(|x: &i32, y: &i32| println!("Dimensions: {}, {}", x, y));
    print_with.accept_once(&800, &600);
    println!();

    // 12. Converting to function
    println!("12. Converting to function:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    });
    let func = consumer.into_fn_once();
    func(&7, &3);
    println!("  Log: {:?}\n", *log.lock().unwrap());

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

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

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

Creates a new BoxBiConsumerOnce 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 BoxBiConsumerOnce<T, U> instance with the specified name

Examples

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

let log = Arc::new(Mutex::new(Vec::new()));
let l = log.clone();
let consumer = BoxBiConsumerOnce::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_once(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![8]);

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

Gets the name of the consumer

Examples found in repository

examples/bi_consumer_once_demo.rs (line 134)

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

    // 1. Basic usage
    println!("1. Basic usage:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
        println!("  Sum: {}", x + y);
    });
    consumer.accept_once(&10, &5);
    println!("  Log: {:?}\n", *log.lock().unwrap());

    // 2. Method chaining
    println!("2. Method chaining:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let chained = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l1.lock().unwrap().push(*x + *y);
        println!("  First: sum={}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock().unwrap().push(*x * *y);
        println!("  Second: product={}", x * y);
    });
    chained.accept_once(&5, &3);
    println!("  Log: {:?}\n", *log.lock().unwrap());

    // 3. Conditional execution - true case
    println!("3. Conditional execution - true case:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let conditional = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
    conditional.accept_once(&5, &3);
    println!("  Positive values: {:?}\n", *log.lock().unwrap());

    // 4. Conditional execution - false case
    println!("4. Conditional execution - false case:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let conditional = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
    conditional.accept_once(&-5, &3);
    println!("  Negative value (unchanged): {:?}\n", *log.lock().unwrap());

    // 5. Conditional branching
    println!("5. Conditional branching:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let branch = BoxBiConsumerOnce::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_once(&15, &10);
    println!("  When x > y: {:?}\n", *log.lock().unwrap());

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

    // 7. Moving captured values
    println!("7. Moving captured values:");
    let data = vec![1, 2, 3, 4, 5];
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        println!("  x={}, y={}", x, y);
        println!("  Captured data: {:?}", data);
        println!("  Data sum: {}", data.iter().sum::<i32>());
    });
    consumer.accept_once(&5, &3);
    // data is no longer available here
    println!();

    // 8. Initialization callback
    println!("8. Initialization callback:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let init_callback = BoxBiConsumerOnce::new(move |width: &i32, height: &i32| {
        println!("  Initializing with dimensions: {}x{}", width, height);
        l.lock().unwrap().push(*width * *height);
    });
    init_callback.accept_once(&800, &600);
    println!("  Areas: {:?}\n", *log.lock().unwrap());

    // 9. Cleanup callback
    println!("9. Cleanup callback:");
    let cleanup = BoxBiConsumerOnce::new(|count: &i32, total: &i32| {
        println!("  Cleanup: processed {} out of {} items", count, total);
        println!(
            "  Success rate: {:.1}%",
            (*count as f64 / *total as f64) * 100.0
        );
    });
    cleanup.accept_once(&85, &100);
    println!();

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

    named_consumer.set_name("init_callback");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}", named_consumer);
    named_consumer.accept_once(&1, &2);
    println!();

    // 11. Print helpers
    println!("11. Print helpers:");
    let print = BoxBiConsumerOnce::new(|x: &i32, y: &i32| println!("{}, {}", x, y));
    print.accept_once(&42, &10);

    let print_with =
        BoxBiConsumerOnce::new(|x: &i32, y: &i32| println!("Dimensions: {}, {}", x, y));
    print_with.accept_once(&800, &600);
    println!();

    // 12. Converting to function
    println!("12. Converting to function:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    });
    let func = consumer.into_fn_once();
    func(&7, &3);
    println!("  Log: {:?}\n", *log.lock().unwrap());

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

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

Sets the name of the consumer

Examples found in repository

examples/bi_consumer_once_demo.rs (line 136)

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

    // 1. Basic usage
    println!("1. Basic usage:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
        println!("  Sum: {}", x + y);
    });
    consumer.accept_once(&10, &5);
    println!("  Log: {:?}\n", *log.lock().unwrap());

    // 2. Method chaining
    println!("2. Method chaining:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let chained = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l1.lock().unwrap().push(*x + *y);
        println!("  First: sum={}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock().unwrap().push(*x * *y);
        println!("  Second: product={}", x * y);
    });
    chained.accept_once(&5, &3);
    println!("  Log: {:?}\n", *log.lock().unwrap());

    // 3. Conditional execution - true case
    println!("3. Conditional execution - true case:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let conditional = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
    conditional.accept_once(&5, &3);
    println!("  Positive values: {:?}\n", *log.lock().unwrap());

    // 4. Conditional execution - false case
    println!("4. Conditional execution - false case:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let conditional = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
    conditional.accept_once(&-5, &3);
    println!("  Negative value (unchanged): {:?}\n", *log.lock().unwrap());

    // 5. Conditional branching
    println!("5. Conditional branching:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let branch = BoxBiConsumerOnce::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_once(&15, &10);
    println!("  When x > y: {:?}\n", *log.lock().unwrap());

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

    // 7. Moving captured values
    println!("7. Moving captured values:");
    let data = vec![1, 2, 3, 4, 5];
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        println!("  x={}, y={}", x, y);
        println!("  Captured data: {:?}", data);
        println!("  Data sum: {}", data.iter().sum::<i32>());
    });
    consumer.accept_once(&5, &3);
    // data is no longer available here
    println!();

    // 8. Initialization callback
    println!("8. Initialization callback:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let init_callback = BoxBiConsumerOnce::new(move |width: &i32, height: &i32| {
        println!("  Initializing with dimensions: {}x{}", width, height);
        l.lock().unwrap().push(*width * *height);
    });
    init_callback.accept_once(&800, &600);
    println!("  Areas: {:?}\n", *log.lock().unwrap());

    // 9. Cleanup callback
    println!("9. Cleanup callback:");
    let cleanup = BoxBiConsumerOnce::new(|count: &i32, total: &i32| {
        println!("  Cleanup: processed {} out of {} items", count, total);
        println!(
            "  Success rate: {:.1}%",
            (*count as f64 / *total as f64) * 100.0
        );
    });
    cleanup.accept_once(&85, &100);
    println!();

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

    named_consumer.set_name("init_callback");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}", named_consumer);
    named_consumer.accept_once(&1, &2);
    println!();

    // 11. Print helpers
    println!("11. Print helpers:");
    let print = BoxBiConsumerOnce::new(|x: &i32, y: &i32| println!("{}, {}", x, y));
    print.accept_once(&42, &10);

    let print_with =
        BoxBiConsumerOnce::new(|x: &i32, y: &i32| println!("Dimensions: {}, {}", x, y));
    print_with.accept_once(&800, &600);
    println!();

    // 12. Converting to function
    println!("12. Converting to function:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    });
    let func = consumer.into_fn_once();
    func(&7, &3);
    println!("  Log: {:?}\n", *log.lock().unwrap());

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

pub fn noop() -> Self

Creates a no-op bi-consumer

Returns

Returns a no-op bi-consumer

Examples

use prism3_function::{BiConsumerOnce, BoxBiConsumerOnce};

let noop = BoxBiConsumerOnce::<i32, i32>::noop();
noop.accept_once(&42, &10);
// Values unchanged

Examples found in repository

examples/bi_consumer_once_demo.rs (line 133)

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

    // 1. Basic usage
    println!("1. Basic usage:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
        println!("  Sum: {}", x + y);
    });
    consumer.accept_once(&10, &5);
    println!("  Log: {:?}\n", *log.lock().unwrap());

    // 2. Method chaining
    println!("2. Method chaining:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let chained = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l1.lock().unwrap().push(*x + *y);
        println!("  First: sum={}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock().unwrap().push(*x * *y);
        println!("  Second: product={}", x * y);
    });
    chained.accept_once(&5, &3);
    println!("  Log: {:?}\n", *log.lock().unwrap());

    // 3. Conditional execution - true case
    println!("3. Conditional execution - true case:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let conditional = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
    conditional.accept_once(&5, &3);
    println!("  Positive values: {:?}\n", *log.lock().unwrap());

    // 4. Conditional execution - false case
    println!("4. Conditional execution - false case:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let conditional = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
    conditional.accept_once(&-5, &3);
    println!("  Negative value (unchanged): {:?}\n", *log.lock().unwrap());

    // 5. Conditional branching
    println!("5. Conditional branching:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let branch = BoxBiConsumerOnce::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_once(&15, &10);
    println!("  When x > y: {:?}\n", *log.lock().unwrap());

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

    // 7. Moving captured values
    println!("7. Moving captured values:");
    let data = vec![1, 2, 3, 4, 5];
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        println!("  x={}, y={}", x, y);
        println!("  Captured data: {:?}", data);
        println!("  Data sum: {}", data.iter().sum::<i32>());
    });
    consumer.accept_once(&5, &3);
    // data is no longer available here
    println!();

    // 8. Initialization callback
    println!("8. Initialization callback:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let init_callback = BoxBiConsumerOnce::new(move |width: &i32, height: &i32| {
        println!("  Initializing with dimensions: {}x{}", width, height);
        l.lock().unwrap().push(*width * *height);
    });
    init_callback.accept_once(&800, &600);
    println!("  Areas: {:?}\n", *log.lock().unwrap());

    // 9. Cleanup callback
    println!("9. Cleanup callback:");
    let cleanup = BoxBiConsumerOnce::new(|count: &i32, total: &i32| {
        println!("  Cleanup: processed {} out of {} items", count, total);
        println!(
            "  Success rate: {:.1}%",
            (*count as f64 / *total as f64) * 100.0
        );
    });
    cleanup.accept_once(&85, &100);
    println!();

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

    named_consumer.set_name("init_callback");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}", named_consumer);
    named_consumer.accept_once(&1, &2);
    println!();

    // 11. Print helpers
    println!("11. Print helpers:");
    let print = BoxBiConsumerOnce::new(|x: &i32, y: &i32| println!("{}, {}", x, y));
    print.accept_once(&42, &10);

    let print_with =
        BoxBiConsumerOnce::new(|x: &i32, y: &i32| println!("Dimensions: {}, {}", x, y));
    print_with.accept_once(&800, &600);
    println!();

    // 12. Converting to function
    println!("12. Converting to function:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    });
    let func = consumer.into_fn_once();
    func(&7, &3);
    println!("  Log: {:?}\n", *log.lock().unwrap());

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

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

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

Chains another one-time bi-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. Since BoxBiConsumerOnce cannot be cloned, the parameter will be consumed. Can be:
  • A closure: |x: &T, y: &U|
  • A BoxBiConsumerOnce<T, U>
  • Any type implementing BiConsumerOnce<T, U>

Returns

Returns a new composed BoxBiConsumerOnce<T, U>

Examples

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

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

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

Examples found in repository

examples/bi_consumer_once_demo.rs (lines 41-44)

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

    // 1. Basic usage
    println!("1. Basic usage:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
        println!("  Sum: {}", x + y);
    });
    consumer.accept_once(&10, &5);
    println!("  Log: {:?}\n", *log.lock().unwrap());

    // 2. Method chaining
    println!("2. Method chaining:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let chained = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l1.lock().unwrap().push(*x + *y);
        println!("  First: sum={}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock().unwrap().push(*x * *y);
        println!("  Second: product={}", x * y);
    });
    chained.accept_once(&5, &3);
    println!("  Log: {:?}\n", *log.lock().unwrap());

    // 3. Conditional execution - true case
    println!("3. Conditional execution - true case:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let conditional = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
    conditional.accept_once(&5, &3);
    println!("  Positive values: {:?}\n", *log.lock().unwrap());

    // 4. Conditional execution - false case
    println!("4. Conditional execution - false case:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let conditional = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
    conditional.accept_once(&-5, &3);
    println!("  Negative value (unchanged): {:?}\n", *log.lock().unwrap());

    // 5. Conditional branching
    println!("5. Conditional branching:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let branch = BoxBiConsumerOnce::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_once(&15, &10);
    println!("  When x > y: {:?}\n", *log.lock().unwrap());

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

    // 7. Moving captured values
    println!("7. Moving captured values:");
    let data = vec![1, 2, 3, 4, 5];
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        println!("  x={}, y={}", x, y);
        println!("  Captured data: {:?}", data);
        println!("  Data sum: {}", data.iter().sum::<i32>());
    });
    consumer.accept_once(&5, &3);
    // data is no longer available here
    println!();

    // 8. Initialization callback
    println!("8. Initialization callback:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let init_callback = BoxBiConsumerOnce::new(move |width: &i32, height: &i32| {
        println!("  Initializing with dimensions: {}x{}", width, height);
        l.lock().unwrap().push(*width * *height);
    });
    init_callback.accept_once(&800, &600);
    println!("  Areas: {:?}\n", *log.lock().unwrap());

    // 9. Cleanup callback
    println!("9. Cleanup callback:");
    let cleanup = BoxBiConsumerOnce::new(|count: &i32, total: &i32| {
        println!("  Cleanup: processed {} out of {} items", count, total);
        println!(
            "  Success rate: {:.1}%",
            (*count as f64 / *total as f64) * 100.0
        );
    });
    cleanup.accept_once(&85, &100);
    println!();

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

    named_consumer.set_name("init_callback");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}", named_consumer);
    named_consumer.accept_once(&1, &2);
    println!();

    // 11. Print helpers
    println!("11. Print helpers:");
    let print = BoxBiConsumerOnce::new(|x: &i32, y: &i32| println!("{}, {}", x, y));
    print.accept_once(&42, &10);

    let print_with =
        BoxBiConsumerOnce::new(|x: &i32, y: &i32| println!("Dimensions: {}, {}", x, y));
    print_with.accept_once(&800, &600);
    println!();

    // 12. Converting to function
    println!("12. Converting to function:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    });
    let func = consumer.into_fn_once();
    func(&7, &3);
    println!("  Log: {:?}\n", *log.lock().unwrap());

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

pub fn when<P>(self, predicate: P) -> BoxConditionalBiConsumerOnce<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.

Type Parameters

• P - The predicate type

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>
  • Any type implementing BiPredicate<T, U>

Returns

Returns BoxConditionalBiConsumerOnce<T, U>

Examples

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

let log = Arc::new(Mutex::new(Vec::new()));
let l = log.clone();
let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
    l.lock().unwrap().push(*x + *y);
});
let conditional = consumer.when(|x: &i32, y: &i32| *x > 0 && *y > 0);

conditional.accept_once(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![8]);

Examples found in repository

examples/bi_consumer_once_demo.rs (line 55)

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

    // 1. Basic usage
    println!("1. Basic usage:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
        println!("  Sum: {}", x + y);
    });
    consumer.accept_once(&10, &5);
    println!("  Log: {:?}\n", *log.lock().unwrap());

    // 2. Method chaining
    println!("2. Method chaining:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let chained = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l1.lock().unwrap().push(*x + *y);
        println!("  First: sum={}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock().unwrap().push(*x * *y);
        println!("  Second: product={}", x * y);
    });
    chained.accept_once(&5, &3);
    println!("  Log: {:?}\n", *log.lock().unwrap());

    // 3. Conditional execution - true case
    println!("3. Conditional execution - true case:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let conditional = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
    conditional.accept_once(&5, &3);
    println!("  Positive values: {:?}\n", *log.lock().unwrap());

    // 4. Conditional execution - false case
    println!("4. Conditional execution - false case:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let conditional = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
    conditional.accept_once(&-5, &3);
    println!("  Negative value (unchanged): {:?}\n", *log.lock().unwrap());

    // 5. Conditional branching
    println!("5. Conditional branching:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let branch = BoxBiConsumerOnce::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_once(&15, &10);
    println!("  When x > y: {:?}\n", *log.lock().unwrap());

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

    // 7. Moving captured values
    println!("7. Moving captured values:");
    let data = vec![1, 2, 3, 4, 5];
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        println!("  x={}, y={}", x, y);
        println!("  Captured data: {:?}", data);
        println!("  Data sum: {}", data.iter().sum::<i32>());
    });
    consumer.accept_once(&5, &3);
    // data is no longer available here
    println!();

    // 8. Initialization callback
    println!("8. Initialization callback:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let init_callback = BoxBiConsumerOnce::new(move |width: &i32, height: &i32| {
        println!("  Initializing with dimensions: {}x{}", width, height);
        l.lock().unwrap().push(*width * *height);
    });
    init_callback.accept_once(&800, &600);
    println!("  Areas: {:?}\n", *log.lock().unwrap());

    // 9. Cleanup callback
    println!("9. Cleanup callback:");
    let cleanup = BoxBiConsumerOnce::new(|count: &i32, total: &i32| {
        println!("  Cleanup: processed {} out of {} items", count, total);
        println!(
            "  Success rate: {:.1}%",
            (*count as f64 / *total as f64) * 100.0
        );
    });
    cleanup.accept_once(&85, &100);
    println!();

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

    named_consumer.set_name("init_callback");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}", named_consumer);
    named_consumer.accept_once(&1, &2);
    println!();

    // 11. Print helpers
    println!("11. Print helpers:");
    let print = BoxBiConsumerOnce::new(|x: &i32, y: &i32| println!("{}, {}", x, y));
    print.accept_once(&42, &10);

    let print_with =
        BoxBiConsumerOnce::new(|x: &i32, y: &i32| println!("Dimensions: {}, {}", x, y));
    print_with.accept_once(&800, &600);
    println!();

    // 12. Converting to function
    println!("12. Converting to function:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock().unwrap().push(*x + *y);
    });
    let func = consumer.into_fn_once();
    func(&7, &3);
    println!("  Log: {:?}\n", *log.lock().unwrap());

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

Trait Implementations

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

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

Performs the one-time consumption operation

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

where T: 'static, U: 'static,

Converts to BoxBiConsumerOnce

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

where T: 'static, U: 'static,

Converts to a closure

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.