Trait BiConsumerOnce 

pub trait BiConsumerOnce<T, U> {
    // Required methods
    fn accept(self, first: &T, second: &U);
    fn into_box(self) -> BoxBiConsumerOnce<T, U>
       where Self: Sized + 'static,
             T: 'static,
             U: 'static;
    fn into_fn(self) -> impl FnOnce(&T, &U)
       where Self: Sized + 'static,
             T: 'static,
             U: 'static;
}

BiConsumerOnce trait - Unified one-time bi-consumer interface

Defines core behavior for all one-time bi-consumer types. Similar to a bi-consumer implementing FnOnce(&T, &U), performs operations accepting two value references but returning no result (side effects only), consuming itself in the process.

Automatic Implementations

• All closures implementing FnOnce(&T, &U)
• BoxBiConsumerOnce<T, U>

Features

• Unified Interface: All bi-consumer types share the same accept method signature
• Automatic Implementation: Closures automatically implement this trait with zero overhead
• Type Conversions: Can convert to BoxBiConsumerOnce
• Generic Programming: Write functions accepting any one-time bi-consumer type

Examples

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

fn apply_consumer<C: BiConsumerOnce<i32, i32>>(
    consumer: C,
    a: &i32,
    b: &i32
) {
    consumer.accept(a, b);
}

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

Author

Haixing Hu

Required Methods

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

Performs the one-time consumption operation

Executes an operation on the given two references. The operation typically reads input values or produces side effects, but does not modify the input values themselves. Consumes self.

Parameters

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

Examples

use prism3_function::{BiConsumerOnce, BoxBiConsumerOnce};

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

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

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

Converts to BoxBiConsumerOnce

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

Returns

Returns the wrapped BoxBiConsumerOnce<T, U>

Examples

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

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);
};
let box_consumer = closure.into_box();
box_consumer.accept(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![8]);

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

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

Converts to a closure

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

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

Returns

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

Implementors

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

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

where T: 'static, U: 'static,

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

where F: FnOnce(&T, &U),

Implements BiConsumerOnce for all FnOnce(&T, &U)