qubit_function::transformers::transformer

Struct BoxConditionalTransformer

pub struct BoxConditionalTransformer<T, R> { /* private fields */ }

Expand description

BoxConditionalTransformer struct

A conditional transformer that only executes when a predicate is satisfied. Uses BoxTransformer and BoxPredicate for single ownership semantics.

This type is typically created by calling BoxTransformer::when() and is designed to work with the or_else() method to create if-then-else logic.

§Features

Single Ownership: Not cloneable, consumes self on use
Conditional Execution: Only transforms when predicate returns true
Chainable: Can add or_else branch to create if-then-else logic
Implements Transformer: Can be used anywhere a Transformer is expected

§Examples

§With or_else Branch

use qubit_function::{Transformer, BoxTransformer};

let double = BoxTransformer::new(|x: i32| x * 2);
let negate = BoxTransformer::new(|x: i32| -x);
let conditional = double.when(|x: &i32| *x > 0).or_else(negate);

assert_eq!(conditional.apply(5), 10); // when branch executed
assert_eq!(conditional.apply(-5), 5); // or_else branch executed

§Author

Haixing Hu

Implementations§

Source §

impl<T, R> BoxConditionalTransformer<T, R>

Source

pub fn or_else<F>(self, else_transformer: F) -> BoxTransformer<T, R>
where T: 'static, R: 'static, F: Transformer<T, R> + 'static,

Adds an else branch

Executes the original transformer when the condition is satisfied, otherwise executes else_transformer.

§Parameters

else_transformer - The transformer for the else branch

§Returns

Returns a new transformer with if-then-else logic

Examples found in repository ?

examples/transformers/fn_transformer_ops_demo.rs (line 59)

19fn main() {
20    println!("=== FnTransformerOps Example ===\n");
21
22    // 1. Basic and_then composition
23    println!("1. Basic and_then composition:");
24    let double = |x: i32| x * 2;
25    let to_string = |x: i32| x.to_string();
26    let composed = double.and_then(to_string);
27    println!(
28        "   double.and_then(to_string).apply(21) = {}",
29        composed.apply(21)
30    );
31    println!();
32
33    // 2. Chained and_then composition
34    println!("2. Chained and_then composition:");
35    let add_one = |x: i32| x + 1;
36    let double = |x: i32| x * 2;
37    let to_string = |x: i32| x.to_string();
38    let chained = add_one.and_then(double).and_then(to_string);
39    println!(
40        "   add_one.and_then(double).and_then(to_string).apply(5) = {}",
41        chained.apply(5)
42    ); // (5 + 1) * 2 = 12
43    println!();
44
45    // 3. compose reverse composition
46    println!("3. compose reverse composition:");
47    let double = |x: i32| x * 2;
48    let add_one = |x: i32| x + 1;
49    let composed = double.compose(add_one);
50    println!(
51        "   double.compose(add_one).apply(5) = {}",
52        composed.apply(5)
53    ); // (5 + 1) * 2 = 12
54    println!();
55
56    // 4. Conditional transformation when
57    println!("4. Conditional transformation when:");
58    let double = |x: i32| x * 2;
59    let conditional = double.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
60    println!("   double.when(x > 0).or_else(negate):");
61    println!("     transform(5) = {}", conditional.apply(5)); // 10
62    println!("     transform(-5) = {}", conditional.apply(-5)); // 5
63    println!();
64
65    // 5. Complex composition
66    println!("5. Complex composition:");
67    let add_one = |x: i32| x + 1;
68    let double = |x: i32| x * 2;
69    let triple = |x: i32| x * 3;
70    let to_string = |x: i32| x.to_string();
71
72    let complex = add_one
73        .and_then(double.when(|x: &i32| *x > 5).or_else(triple))
74        .and_then(to_string);
75
76    println!("   add_one.and_then(double.when(x > 5).or_else(triple)).and_then(to_string):");
77    println!("     transform(1) = {}", complex.apply(1)); // (1 + 1) = 2 <= 5, so 2 * 3 = 6
78    println!("     transform(5) = {}", complex.apply(5)); // (5 + 1) = 6 > 5, so 6 * 2 = 12
79    println!("     transform(10) = {}", complex.apply(10)); // (10 + 1) = 11 > 5, so 11 * 2 = 22
80    println!();
81
82    // 6. Type conversion
83    println!("6. Type conversion:");
84    let to_string = |x: i32| x.to_string();
85    let get_length = |s: String| s.len();
86    let length_transformer = to_string.and_then(get_length);
87    println!(
88        "   to_string.and_then(get_length).apply(12345) = {}",
89        length_transformer.apply(12345)
90    ); // 5
91    println!();
92
93    // 7. Closures that capture environment
94    println!("7. Closures that capture environment:");
95    let multiplier = 3;
96    let multiply = move |x: i32| x * multiplier;
97    let add_ten = |x: i32| x + 10;
98    let with_capture = multiply.and_then(add_ten);
99    println!(
100        "   multiply(3).and_then(add_ten).apply(5) = {}",
101        with_capture.apply(5)
102    ); // 5 * 3 + 10 = 25
103    println!();
104
105    // 8. Function pointers
106    println!("8. Function pointers:");
107    fn double_fn(x: i32) -> i32 {
108        x * 2
109    }
110    fn add_one_fn(x: i32) -> i32 {
111        x + 1
112    }
113    let fn_composed = double_fn.and_then(add_one_fn);
114    println!(
115        "   double_fn.and_then(add_one_fn).apply(5) = {}",
116        fn_composed.apply(5)
117    ); // 5 * 2 + 1 = 11
118    println!();
119
120    // 9. Multi-conditional transformation
121    println!("9. Multi-conditional transformation:");
122    let abs = |x: i32| x.abs();
123    let double = |x: i32| x * 2;
124    let transformer = abs.when(|x: &i32| *x < 0).or_else(double);
125    println!("   abs.when(x < 0).or_else(double):");
126    println!("     transform(-5) = {}", transformer.apply(-5)); // abs(-5) = 5
127    println!("     transform(5) = {}", transformer.apply(5)); // 5 * 2 = 10
128    println!("     transform(0) = {}", transformer.apply(0)); // 0 * 2 = 0
129    println!();
130
131    println!("=== Example completed ===");
132}