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().expect("mutex should not be poisoned").push(*x + *y);
});
apply_consumer(box_con, &5, &3);
assert_eq!(*log.lock().expect("mutex should not be poisoned"), vec![8]);

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

Dyn Compatibility§

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

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>