always_bi_predicate_demo/
always_bi_predicate_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 ******************************************************************************/
10use qubit_function::{
11    ArcBiPredicate,
12    BiPredicate,
13    BoxBiPredicate,
14    RcBiPredicate,
15};
16
17fn main() {
18    println!("=== BoxBiPredicate always_true/always_false Demo ===\n");
19
20    // BoxBiPredicate::always_true
21    let always_true: BoxBiPredicate<i32, i32> = BoxBiPredicate::always_true();
22    println!("BoxBiPredicate::always_true():");
23    println!("  test(&42, &10): {}", always_true.test(&42, &10));
24    println!("  test(&-1, &5): {}", always_true.test(&-1, &5));
25    println!("  test(&0, &0): {}", always_true.test(&0, &0));
26    println!("  name: {:?}", always_true.name());
27
28    // BoxBiPredicate::always_false
29    let always_false: BoxBiPredicate<i32, i32> = BoxBiPredicate::always_false();
30    println!("\nBoxBiPredicate::always_false():");
31    println!("  test(&42, &10): {}", always_false.test(&42, &10));
32    println!("  test(&-1, &5): {}", always_false.test(&-1, &5));
33    println!("  test(&0, &0): {}", always_false.test(&0, &0));
34    println!("  name: {:?}", always_false.name());
35
36    println!("\n=== RcBiPredicate always_true/always_false Demo ===\n");
37
38    // RcBiPredicate::always_true
39    let rc_always_true: RcBiPredicate<String, i32> = RcBiPredicate::always_true();
40    println!("RcBiPredicate::always_true():");
41    println!(
42        "  test(&\"hello\", &5): {}",
43        rc_always_true.test(&"hello".to_string(), &5)
44    );
45    println!(
46        "  test(&\"world\", &-3): {}",
47        rc_always_true.test(&"world".to_string(), &-3)
48    );
49    println!("  name: {:?}", rc_always_true.name());
50
51    // RcBiPredicate::always_false
52    let rc_always_false: RcBiPredicate<String, i32> = RcBiPredicate::always_false();
53    println!("\nRcBiPredicate::always_false():");
54    println!(
55        "  test(&\"hello\", &5): {}",
56        rc_always_false.test(&"hello".to_string(), &5)
57    );
58    println!(
59        "  test(&\"world\", &-3): {}",
60        rc_always_false.test(&"world".to_string(), &-3)
61    );
62    println!("  name: {:?}", rc_always_false.name());
63
64    // Can be cloned and reused
65    let rc_clone = rc_always_true.clone();
66    println!("\nAfter cloning, still usable:");
67    println!(
68        "  Original: test(&\"test\", &1): {}",
69        rc_always_true.test(&"test".to_string(), &1)
70    );
71    println!(
72        "  Clone: test(&\"test\", &2): {}",
73        rc_clone.test(&"test".to_string(), &2)
74    );
75
76    println!("\n=== ArcBiPredicate always_true/always_false Demo ===\n");
77
78    // ArcBiPredicate::always_true
79    let arc_always_true: ArcBiPredicate<i32, i32> = ArcBiPredicate::always_true();
80    println!("ArcBiPredicate::always_true():");
81    println!("  test(&100, &50): {}", arc_always_true.test(&100, &50));
82    println!("  test(&-100, &25): {}", arc_always_true.test(&-100, &25));
83    println!("  name: {:?}", arc_always_true.name());
84
85    // ArcBiPredicate::always_false
86    let arc_always_false: ArcBiPredicate<i32, i32> = ArcBiPredicate::always_false();
87    println!("\nArcBiPredicate::always_false():");
88    println!("  test(&100, &50): {}", arc_always_false.test(&100, &50));
89    println!("  test(&-100, &25): {}", arc_always_false.test(&-100, &25));
90    println!("  name: {:?}", arc_always_false.name());
91
92    println!("\n=== Combining with other bi-predicates ===\n");
93
94    // Combining with always_true (AND)
95    let sum_positive = BoxBiPredicate::new(|x: &i32, y: &i32| x + y > 0);
96    let combined_and_true = sum_positive.and(BoxBiPredicate::always_true());
97    println!("sum_positive AND always_true:");
98    println!(
99        "  test(&5, &3): {} (equivalent to sum_positive)",
100        combined_and_true.test(&5, &3)
101    );
102    println!(
103        "  test(&-3, &-5): {} (equivalent to sum_positive)",
104        combined_and_true.test(&-3, &-5)
105    );
106
107    // Combining with always_false (AND)
108    let sum_positive = BoxBiPredicate::new(|x: &i32, y: &i32| x + y > 0);
109    let combined_and_false = sum_positive.and(BoxBiPredicate::always_false());
110    println!("\nsum_positive AND always_false:");
111    println!(
112        "  test(&5, &3): {} (always false)",
113        combined_and_false.test(&5, &3)
114    );
115    println!(
116        "  test(&-3, &-5): {} (always false)",
117        combined_and_false.test(&-3, &-5)
118    );
119
120    // Combining with always_true (OR)
121    let sum_positive = BoxBiPredicate::new(|x: &i32, y: &i32| x + y > 0);
122    let combined_or_true = sum_positive.or(BoxBiPredicate::always_true());
123    println!("\nsum_positive OR always_true:");
124    println!(
125        "  test(&5, &3): {} (always true)",
126        combined_or_true.test(&5, &3)
127    );
128    println!(
129        "  test(&-3, &-5): {} (always true)",
130        combined_or_true.test(&-3, &-5)
131    );
132
133    // Combining with always_false (OR)
134    let sum_positive = BoxBiPredicate::new(|x: &i32, y: &i32| x + y > 0);
135    let combined_or_false = sum_positive.or(BoxBiPredicate::always_false());
136    println!("\nsum_positive OR always_false:");
137    println!(
138        "  test(&5, &3): {} (equivalent to sum_positive)",
139        combined_or_false.test(&5, &3)
140    );
141    println!(
142        "  test(&-3, &-5): {} (equivalent to sum_positive)",
143        combined_or_false.test(&-3, &-5)
144    );
145
146    println!("\n=== Practical scenarios: Default pass/reject filters ===\n");
147
148    // Scenario 1: Default pass-all filter
149    let pairs = vec![(1, 2), (3, 4), (5, 6)];
150    let pass_all = BoxBiPredicate::<i32, i32>::always_true();
151    let closure = pass_all.into_fn();
152    let filtered: Vec<_> = pairs.iter().filter(|(x, y)| closure(x, y)).collect();
153    println!("Default pass all elements: {:?} -> {:?}", pairs, filtered);
154
155    // Scenario 2: Default reject-all filter
156    let pairs = vec![(1, 2), (3, 4), (5, 6)];
157    let reject_all = BoxBiPredicate::<i32, i32>::always_false();
158    let closure = reject_all.into_fn();
159    let filtered: Vec<_> = pairs.iter().filter(|(x, y)| closure(x, y)).collect();
160    println!("Default reject all elements: {:?} -> {:?}", pairs, filtered);
161
162    // Scenario 3: Configurable filter
163    fn configurable_filter(enable_filter: bool) -> BoxBiPredicate<i32, i32> {
164        if enable_filter {
165            BoxBiPredicate::new(|x: &i32, y: &i32| x + y > 5)
166        } else {
167            BoxBiPredicate::always_true()
168        }
169    }
170
171    let pairs = vec![(1, 2), (3, 4), (5, 6)];
172
173    let filter_enabled = configurable_filter(true);
174    let closure = filter_enabled.into_fn();
175    let filtered: Vec<_> = pairs.iter().filter(|(x, y)| closure(x, y)).collect();
176    println!("\nFilter enabled: {:?} -> {:?}", pairs, filtered);
177
178    let filter_disabled = configurable_filter(false);
179    let closure = filter_disabled.into_fn();
180    let filtered: Vec<_> = pairs.iter().filter(|(x, y)| closure(x, y)).collect();
181    println!("Filter disabled: {:?} -> {:?}", pairs, filtered);
182}
always_bi_predicate_demo/always_bi_predicate_demo.rs

always_bi_predicate_demo/
always_bi_predicate_demo.rs
