consumer_once_demo/
consumer_once_demo.rs

1/*******************************************************************************
2 *
3 *    Copyright (c) 2025 - 2026.
4 *    Haixing Hu, Qubit Co. Ltd.
5 *
6 *    All rights reserved.
7 *
8 ******************************************************************************/
9//! # ConsumerOnce Demo
10//!
11//! Demonstrates the usage of ConsumerOnce trait and its implementations.
12
13use qubit_function::{
14    BoxConsumerOnce,
15    ConsumerOnce,
16    FnConsumerOnceOps,
17};
18use std::sync::{
19    Arc,
20    Mutex,
21};
22
23fn main() {
24    println!("=== ConsumerOnce Demo ===\n");
25
26    // 1. BoxConsumerOnce - Single ownership, one-time use
27    println!("1. BoxConsumerOnce - Single ownership");
28    {
29        let log = Arc::new(Mutex::new(Vec::new()));
30        let l = log.clone();
31        let consumer = BoxConsumerOnce::new(move |x: &i32| {
32            l.lock().unwrap().push(*x);
33            println!("  BoxConsumerOnce consumed: {}", x);
34        });
35        consumer.accept(&42);
36        println!("  Log: {:?}\n", *log.lock().unwrap());
37    }
38
39    // 2. BoxConsumerOnce - Method chaining
40    println!("2. BoxConsumerOnce - Method chaining");
41    {
42        let log = Arc::new(Mutex::new(Vec::new()));
43        let l1 = log.clone();
44        let l2 = log.clone();
45        let l3 = log.clone();
46        let chained = BoxConsumerOnce::new(move |x: &i32| {
47            l1.lock().unwrap().push(*x * 2);
48            println!("  Step 1: {} * 2 = {}", x, x * 2);
49        })
50        .and_then(move |x: &i32| {
51            l2.lock().unwrap().push(*x + 10);
52            println!("  Step 2: {} + 10 = {}", x, x + 10);
53        })
54        .and_then(move |x: &i32| {
55            l3.lock().unwrap().push(*x - 1);
56            println!("  Step 3: {} - 1 = {}", x, x - 1);
57        });
58        chained.accept(&5);
59        println!("  Log: {:?}\n", *log.lock().unwrap());
60    }
61
62    // 3. BoxConsumerOnce - Factory methods
63    println!("3. BoxConsumerOnce - Factory methods");
64    {
65        // No-op consumer
66        let noop = BoxConsumerOnce::<i32>::noop();
67        noop.accept(&42);
68        println!("  No-op consumer executed (no output)");
69
70        // Print consumer
71        print!("  Print consumer: ");
72        let print = BoxConsumerOnce::new(|x: &i32| println!("{}", x));
73        print.accept(&42);
74
75        // Print with prefix
76        print!("  Print with prefix: ");
77        let print_with = BoxConsumerOnce::new(|x: &i32| println!("Value: {}", x));
78        print_with.accept(&42);
79
80        // Conditional consumer
81        let log = Arc::new(Mutex::new(Vec::new()));
82        let l = log.clone();
83        let conditional = BoxConsumerOnce::new(move |x: &i32| {
84            l.lock().unwrap().push(*x * 2);
85        })
86        .when(|x: &i32| *x > 0);
87        conditional.accept(&5);
88        println!("  Conditional (positive): {:?}", *log.lock().unwrap());
89
90        let log = Arc::new(Mutex::new(Vec::new()));
91        let l = log.clone();
92        let conditional = BoxConsumerOnce::new(move |x: &i32| {
93            l.lock().unwrap().push(*x * 2);
94        })
95        .when(|x: &i32| *x > 0);
96        conditional.accept(&-5);
97        println!("  Conditional (negative): {:?}\n", *log.lock().unwrap());
98    }
99
100    // 4. Closure usage
101    println!("4. Closure usage");
102    {
103        let log = Arc::new(Mutex::new(Vec::new()));
104        let l = log.clone();
105        let closure = move |x: &i32| {
106            l.lock().unwrap().push(*x * 2);
107            println!("  Closure consumed: {}", x);
108        };
109        closure.accept(&42);
110        println!("  Log: {:?}\n", *log.lock().unwrap());
111    }
112
113    // 5. Closure chaining
114    println!("5. Closure chaining");
115    {
116        let log = Arc::new(Mutex::new(Vec::new()));
117        let l1 = log.clone();
118        let l2 = log.clone();
119        let chained = (move |x: &i32| {
120            l1.lock().unwrap().push(*x * 2);
121            println!("  Closure 1: {} * 2 = {}", x, x * 2);
122        })
123        .and_then(move |x: &i32| {
124            l2.lock().unwrap().push(*x + 10);
125            println!("  Closure 2: {} + 10 = {}", x, x + 10);
126        });
127        chained.accept(&5);
128        println!("  Log: {:?}\n", *log.lock().unwrap());
129    }
130
131    // 6. Type conversions
132    println!("6. Type conversions");
133    {
134        let log = Arc::new(Mutex::new(Vec::new()));
135
136        // Closure to BoxConsumerOnce
137        let l = log.clone();
138        let closure = move |x: &i32| {
139            l.lock().unwrap().push(*x);
140        };
141        let box_consumer = closure.into_box();
142        box_consumer.accept(&1);
143        println!("  BoxConsumerOnce: {:?}", *log.lock().unwrap());
144    }
145
146    // 7. Using with iterators (BoxConsumerOnce)
147    println!("7. Using with iterators");
148    {
149        let log = Arc::new(Mutex::new(Vec::new()));
150        let l = log.clone();
151        let consumer = BoxConsumerOnce::new(move |x: &i32| {
152            l.lock().unwrap().push(*x * 2);
153        });
154        // Note: This will panic because BoxConsumerOnce can only be called once
155        // vec![1, 2, 3, 4, 5].iter().for_each(consumer.into_fn());
156        consumer.accept(&1);
157        println!(
158            "  BoxConsumerOnce with single value: {:?}\n",
159            *log.lock().unwrap()
160        );
161    }
162
163    println!("=== Demo Complete ===");
164}
consumer_once_demo/consumer_once_demo.rs

consumer_once_demo/
consumer_once_demo.rs
