bi_consumer_demo/
bi_consumer_demo.rs

1/*******************************************************************************
2 *
3 *    Copyright (c) 2025 - 2026 Haixing Hu.
4 *
5 *    SPDX-License-Identifier: Apache-2.0
6 *
7 *    Licensed under the Apache License, Version 2.0.
8 *
9 ******************************************************************************/
10
11//! BiConsumer demonstration
12//!
13//! This example demonstrates the usage of BiConsumer types after
14//! refactoring to use &T, &U semantics (not modifying input values).
15
16use qubit_function::{
17    ArcBiConsumer,
18    BiConsumer,
19    BoxBiConsumer,
20    BoxStatefulBiConsumer,
21    RcBiConsumer,
22    StatefulBiConsumer,
23};
24use std::cell::RefCell;
25use std::rc::Rc;
26use std::sync::{
27    Arc,
28    Mutex,
29};
30use std::thread;
31
32fn main() {
33    println!("=== BiConsumer Demo ===\n");
34
35    // 1. BoxBiConsumer - Single ownership
36    println!("1. BoxBiConsumer - Single ownership:");
37    let log = Arc::new(Mutex::new(Vec::new()));
38    let l = log.clone();
39    let box_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
40        println!("  Processing: x={}, y={}", x, y);
41        l.lock()
42            .expect("mutex should not be poisoned")
43            .push(*x + *y);
44    });
45    box_consumer.accept(&10, &5);
46    println!(
47        "  Result log: {:?}\n",
48        *log.lock().expect("mutex should not be poisoned")
49    );
50
51    // 2. Method chaining with BoxBiConsumer
52    println!("2. BoxBiConsumer with method chaining:");
53    let log = Arc::new(Mutex::new(Vec::new()));
54    let l1 = log.clone();
55    let l2 = log.clone();
56    let chained = BoxBiConsumer::new(move |x: &i32, y: &i32| {
57        l1.lock()
58            .expect("mutex should not be poisoned")
59            .push(*x + *y);
60        println!("  After first operation: sum = {}", x + y);
61    })
62    .and_then(move |x: &i32, y: &i32| {
63        l2.lock()
64            .expect("mutex should not be poisoned")
65            .push(*x * *y);
66        println!("  After second operation: product = {}", x * y);
67    });
68    chained.accept(&5, &3);
69    println!(
70        "  Final log: {:?}\n",
71        *log.lock().expect("mutex should not be poisoned")
72    );
73
74    // 3. ArcBiConsumer - Thread-safe shared ownership
75    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
76    let log = Arc::new(Mutex::new(Vec::new()));
77    let l = log.clone();
78    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
79        l.lock()
80            .expect("mutex should not be poisoned")
81            .push(*x + *y);
82        println!("  Thread {:?}: sum = {}", thread::current().id(), x + y);
83    });
84
85    let consumer1 = arc_consumer.clone();
86    let consumer2 = arc_consumer.clone();
87
88    let handle1 = thread::spawn(move || {
89        let c = consumer1;
90        c.accept(&10, &5);
91    });
92
93    let handle2 = thread::spawn(move || {
94        let c = consumer2;
95        c.accept(&20, &8);
96    });
97
98    handle1.join().expect("thread should not panic");
99    handle2.join().expect("thread should not panic");
100    println!(
101        "  Final log: {:?}\n",
102        *log.lock().expect("mutex should not be poisoned")
103    );
104
105    // 4. RcBiConsumer - Single-threaded shared ownership
106    println!("4. RcBiConsumer - Single-threaded shared ownership:");
107    let log = Rc::new(RefCell::new(Vec::new()));
108    let l = log.clone();
109    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
110        l.borrow_mut().push(*x + *y);
111    });
112
113    let clone1 = rc_consumer.clone();
114    let clone2 = rc_consumer.clone();
115
116    clone1.accept(&5, &3);
117    println!("  After first use: {:?}", *log.borrow());
118
119    clone2.accept(&7, &2);
120    println!("  After second use: {:?}\n", *log.borrow());
121
122    // 5. Working with closures directly
123    println!("5. Working with closures directly:");
124    let log = Arc::new(Mutex::new(Vec::new()));
125    let l = log.clone();
126    let closure = move |x: &i32, y: &i32| {
127        let sum = *x + *y;
128        l.lock().expect("mutex should not be poisoned").push(sum);
129    };
130    closure.accept(&10, &20);
131    println!(
132        "  After closure: {:?}\n",
133        *log.lock().expect("mutex should not be poisoned")
134    );
135
136    // 6. Conditional BiConsumer
137    println!("6. Conditional BiConsumer:");
138    let log = Arc::new(Mutex::new(Vec::new()));
139    let l = log.clone();
140    let mut conditional = BoxStatefulBiConsumer::new(move |x: &i32, y: &i32| {
141        l.lock()
142            .expect("mutex should not be poisoned")
143            .push(*x + *y);
144    })
145    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
146
147    conditional.accept(&5, &3);
148    println!(
149        "  Positive values: {:?}",
150        *log.lock().expect("mutex should not be poisoned")
151    );
152
153    conditional.accept(&-5, &3);
154    println!(
155        "  Negative value (unchanged): {:?}\n",
156        *log.lock().expect("mutex should not be poisoned")
157    );
158
159    // 7. Conditional branch BiConsumer
160    println!("7. Conditional branch BiConsumer:");
161    let log = Arc::new(Mutex::new(Vec::new()));
162    let l1 = log.clone();
163    let l2 = log.clone();
164    let mut branch = BoxStatefulBiConsumer::new(move |x: &i32, _y: &i32| {
165        l1.lock().expect("mutex should not be poisoned").push(*x);
166    })
167    .when(|x: &i32, y: &i32| *x > *y)
168    .or_else(move |_x: &i32, y: &i32| {
169        l2.lock().expect("mutex should not be poisoned").push(*y);
170    });
171
172    branch.accept(&15, &10);
173    println!(
174        "  When x > y: {:?}",
175        *log.lock().expect("mutex should not be poisoned")
176    );
177
178    branch.accept(&5, &10);
179    println!(
180        "  When x <= y: {:?}\n",
181        *log.lock().expect("mutex should not be poisoned")
182    );
183
184    // 8. Accumulating statistics
185    println!("8. Accumulating statistics:");
186    let count = Arc::new(Mutex::new(0));
187    let sum = Arc::new(Mutex::new(0));
188    let c = count.clone();
189    let s = sum.clone();
190    let stats_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
191        *c.lock().expect("mutex should not be poisoned") += 1;
192        *s.lock().expect("mutex should not be poisoned") += x + y;
193    });
194
195    stats_consumer.accept(&5, &3);
196    stats_consumer.accept(&10, &2);
197    stats_consumer.accept(&7, &8);
198
199    println!(
200        "  Count: {}",
201        *count.lock().expect("mutex should not be poisoned")
202    );
203    println!(
204        "  Sum: {}\n",
205        *sum.lock().expect("mutex should not be poisoned")
206    );
207
208    // 9. Name support
209    println!("9. Name support:");
210    let mut named_consumer = BoxBiConsumer::<i32, i32>::noop();
211    println!("  Initial name: {:?}", named_consumer.name());
212
213    named_consumer.set_name("sum_calculator");
214    println!("  After setting name: {:?}", named_consumer.name());
215    println!("  Display: {}\n", named_consumer);
216
217    println!("=== Demo Complete ===");
218}
bi_consumer_demo/bi_consumer_demo.rs

bi_consumer_demo/
bi_consumer_demo.rs
