Trait BiConsumerOnce 

pub trait BiConsumerOnce<T, U> {
    // Required method
    fn accept(self, first: &T, second: &U);

    // Provided methods
    fn into_box(self) -> BoxBiConsumerOnce<T, U>
       where Self: Sized + 'static { ... }
    fn into_fn(self) -> impl FnOnce(&T, &U)
       where Self: Sized + 'static { ... }
    fn to_box(&self) -> BoxBiConsumerOnce<T, U>
       where Self: Sized + Clone + 'static { ... }
    fn to_fn(&self) -> impl FnOnce(&T, &U)
       where Self: Sized + Clone + 'static { ... }
}

BiConsumerOnce trait - Unified one-time bi-consumer interface

It is similar to the FnOnce(&T, &U) trait in the standard library.

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

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

Provided Methods

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

where Self: Sized + 'static,

Converts to BoxBiConsumerOnce

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

Returns

Returns the wrapped BoxBiConsumerOnce<T, U>

Examples

use qubit_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,

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)

fn to_box(&self) -> BoxBiConsumerOnce<T, U>

where Self: Sized + Clone + 'static,

Convert to BoxBiConsumerOnce without consuming self

⚠️ Requires Clone: This method requires Self to implement Clone. Clones the current bi-consumer and then converts the clone to a BoxBiConsumerOnce.

Returns

Returns the wrapped BoxBiConsumerOnce<T, U>

Examples

use qubit_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.to_box();
box_consumer.accept(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![8]);

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

where Self: Sized + Clone + 'static,

Convert to closure without consuming self

⚠️ Requires Clone: This method requires Self to implement Clone. Clones the current bi-consumer and then converts the clone to a closure.

Returns

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

Examples

use qubit_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 func = closure.to_fn();
func(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![8]);

Implementors

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

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

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

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