Skip to main content

BiConsumerOnce

qubit_function::consumers::bi_consumer_once

Trait BiConsumerOnce 

Source 
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 { ... }
}
Expand description

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§

Source

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§

Source

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]);
Source

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)

Examples found in repository?
examples/consumers/bi_consumer_once_demo.rs (line 165)
24fn main() {
25    println!("=== BiConsumerOnce Demo ===\n");
26
27    // 1. Basic usage
28    println!("1. Basic usage:");
29    let log = Arc::new(Mutex::new(Vec::new()));
30    let l = log.clone();
31    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
32        l.lock().unwrap().push(*x + *y);
33        println!("  Sum: {}", x + y);
34    });
35    consumer.accept(&10, &5);
36    println!("  Log: {:?}\n", *log.lock().unwrap());
37
38    // 2. Method chaining
39    println!("2. Method chaining:");
40    let log = Arc::new(Mutex::new(Vec::new()));
41    let l1 = log.clone();
42    let l2 = log.clone();
43    let chained = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
44        l1.lock().unwrap().push(*x + *y);
45        println!("  First: sum={}", x + y);
46    })
47    .and_then(move |x: &i32, y: &i32| {
48        l2.lock().unwrap().push(*x * *y);
49        println!("  Second: product={}", x * y);
50    });
51    chained.accept(&5, &3);
52    println!("  Log: {:?}\n", *log.lock().unwrap());
53
54    // 3. Conditional execution - true case
55    println!("3. Conditional execution - true case:");
56    let log = Arc::new(Mutex::new(Vec::new()));
57    let l = log.clone();
58    let conditional = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
59        l.lock().unwrap().push(*x + *y);
60    })
61    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
62    conditional.accept(&5, &3);
63    println!("  Positive values: {:?}\n", *log.lock().unwrap());
64
65    // 4. Conditional execution - false case
66    println!("4. Conditional execution - false case:");
67    let log = Arc::new(Mutex::new(Vec::new()));
68    let l = log.clone();
69    let conditional = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
70        l.lock().unwrap().push(*x + *y);
71    })
72    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
73    conditional.accept(&-5, &3);
74    println!("  Negative value (unchanged): {:?}\n", *log.lock().unwrap());
75
76    // 5. Conditional branching
77    println!("5. Conditional branching:");
78    let log = Arc::new(Mutex::new(Vec::new()));
79    let l1 = log.clone();
80    let l2 = log.clone();
81    let branch = BoxBiConsumerOnce::new(move |x: &i32, _y: &i32| {
82        l1.lock().unwrap().push(*x);
83    })
84    .when(|x: &i32, y: &i32| *x > *y)
85    .or_else(move |_x: &i32, y: &i32| {
86        l2.lock().unwrap().push(*y);
87    });
88    branch.accept(&15, &10);
89    println!("  When x > y: {:?}\n", *log.lock().unwrap());
90
91    // 6. Working with closures directly
92    println!("6. Working with closures directly:");
93    let log = Arc::new(Mutex::new(Vec::new()));
94    let l = log.clone();
95    let closure = move |x: &i32, y: &i32| {
96        l.lock().unwrap().push(*x + *y);
97        println!("  Processed: {}", x + y);
98    };
99    closure.accept(&10, &20);
100    println!("  Log: {:?}\n", *log.lock().unwrap());
101
102    // 7. Moving captured values
103    println!("7. Moving captured values:");
104    let data = vec![1, 2, 3, 4, 5];
105    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
106        println!("  x={}, y={}", x, y);
107        println!("  Captured data: {:?}", data);
108        println!("  Data sum: {}", data.iter().sum::<i32>());
109    });
110    consumer.accept(&5, &3);
111    // data is no longer available here
112    println!();
113
114    // 8. Initialization callback
115    println!("8. Initialization callback:");
116    let log = Arc::new(Mutex::new(Vec::new()));
117    let l = log.clone();
118    let init_callback = BoxBiConsumerOnce::new(move |width: &i32, height: &i32| {
119        println!("  Initializing with dimensions: {}x{}", width, height);
120        l.lock().unwrap().push(*width * *height);
121    });
122    init_callback.accept(&800, &600);
123    println!("  Areas: {:?}\n", *log.lock().unwrap());
124
125    // 9. Cleanup callback
126    println!("9. Cleanup callback:");
127    let cleanup = BoxBiConsumerOnce::new(|count: &i32, total: &i32| {
128        println!("  Cleanup: processed {} out of {} items", count, total);
129        println!(
130            "  Success rate: {:.1}%",
131            (*count as f64 / *total as f64) * 100.0
132        );
133    });
134    cleanup.accept(&85, &100);
135    println!();
136
137    // 10. Name support
138    println!("10. Name support:");
139    let mut named_consumer = BoxBiConsumerOnce::<i32, i32>::noop();
140    println!("  Initial name: {:?}", named_consumer.name());
141
142    named_consumer.set_name("init_callback");
143    println!("  After setting name: {:?}", named_consumer.name());
144    println!("  Display: {}", named_consumer);
145    named_consumer.accept(&1, &2);
146    println!();
147
148    // 11. Print helpers
149    println!("11. Print helpers:");
150    let print = BoxBiConsumerOnce::new(|x: &i32, y: &i32| println!("{}, {}", x, y));
151    print.accept(&42, &10);
152
153    let print_with =
154        BoxBiConsumerOnce::new(|x: &i32, y: &i32| println!("Dimensions: {}, {}", x, y));
155    print_with.accept(&800, &600);
156    println!();
157
158    // 12. Converting to function
159    println!("12. Converting to function:");
160    let log = Arc::new(Mutex::new(Vec::new()));
161    let l = log.clone();
162    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
163        l.lock().unwrap().push(*x + *y);
164    });
165    let func = consumer.into_fn();
166    func(&7, &3);
167    println!("  Log: {:?}\n", *log.lock().unwrap());
168
169    println!("=== Demo Complete ===");
170}
Source

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]);
Source

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§

Source§

impl<F, T, U> BiConsumerOnce<T, U> for F
where F: FnOnce(&T, &U),

Source§

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

Source§

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