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

consumer_once_demo/
consumer_once_demo.rs
