Struct BoxConditionalBiTransformer 

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

BoxConditionalBiTransformer struct

A conditional bi-transformer that only executes when a bi-predicate is satisfied. Uses BoxBiTransformer and BoxBiPredicate for single ownership semantics.

This type is typically created by calling BoxBiTransformer::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 bi-predicate returns true
• Chainable: Can add or_else branch to create if-then-else logic
• Implements BiTransformer: Can be used anywhere a BiTransformer is expected

Examples

With or_else Branch

use qubit_function::{BiTransformer, BoxBiTransformer};

let add = BoxBiTransformer::new(|x: i32, y: i32| x + y);
let multiply = BoxBiTransformer::new(|x: i32, y: i32| x * y);
let conditional = add.when(|x: &i32, y: &i32| *x > 0).or_else(multiply);

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

Author

Haixing Hu

Implementations

impl<T, U, R> BoxConditionalBiTransformer<T, U, R>

pub fn or_else<F>(self, else_transformer: F) -> BoxBiTransformer<T, U, R>

where T: 'static, U: 'static, R: 'static, F: BiTransformer<T, U, 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 bi-transformer with if-then-else logic

Examples found in repository

examples/transformers/fn_bi_transformer_ops_demo.rs (line 49)

fn main() {
    println!("=== FnBiTransformerOps Demo ===\n");

    // Example 1: Basic and_then composition
    println!("1. Basic and_then composition:");
    let add = |x: i32, y: i32| x + y;
    let double = |x: i32| x * 2;

    let composed = add.and_then(double);
    let result = composed.apply(3, 5);
    println!("   (3 + 5) * 2 = {}", result);
    println!();

    // Example 2: Type conversion and_then
    println!("2. Type conversion and_then:");
    let multiply = |x: i32, y: i32| x * y;
    let to_string = |x: i32| format!("Result: {}", x);

    let composed = multiply.and_then(to_string);
    let result = composed.apply(6, 7);
    println!("   6 * 7 = {}", result);
    println!();

    // Example 3: Conditional execution - when
    println!("3. Conditional execution - when:");
    let add = |x: i32, y: i32| x + y;
    let multiply = |x: i32, y: i32| x * y;

    let conditional = add
        .when(|x: &i32, y: &i32| *x > 0 && *y > 0)
        .or_else(multiply);

    println!("   When both numbers are positive, perform addition, otherwise multiplication:");
    println!("   conditional(5, 3) = {}", conditional.apply(5, 3));
    println!("   conditional(-5, 3) = {}", conditional.apply(-5, 3));
    println!();

    // Example 4: Complex conditional logic
    println!("4. Complex conditional logic:");
    let add = |x: i32, y: i32| x + y;
    let subtract = |x: i32, y: i32| x - y;

    let conditional = add
        .when(|x: &i32, y: &i32| (*x + *y) < 100)
        .or_else(subtract);

    println!("   When sum is less than 100, perform addition, otherwise subtraction:");
    println!("   conditional(30, 40) = {}", conditional.apply(30, 40));
    println!("   conditional(60, 50) = {}", conditional.apply(60, 50));
    println!();

    // Example 5: String operations
    println!("5. String operations:");
    let concat = |x: String, y: String| format!("{}-{}", x, y);
    let uppercase = |s: String| s.to_uppercase();

    let composed = concat.and_then(uppercase);
    let result = composed.apply("hello".to_string(), "world".to_string());
    println!("   concat + uppercase: {}", result);
    println!();

    // Example 6: Function pointers can also be used
    println!("6. Function pointers can also be used:");
    fn add_fn(x: i32, y: i32) -> i32 {
        x + y
    }
    fn triple(x: i32) -> i32 {
        x * 3
    }

    let composed = add_fn.and_then(triple);
    let result = composed.apply(4, 6);
    println!("   (4 + 6) * 3 = {}", result);
    println!();

    // Example 7: Real application - Calculator
    println!("7. Real application - Simple calculator:");
    let calculate = |x: i32, y: i32| x + y;
    let format_result = |result: i32| {
        if result >= 0 {
            format!("✓ Result: {}", result)
        } else {
            format!("✗ Negative result: {}", result)
        }
    };

    let calculator = calculate.and_then(format_result);
    println!("   10 + 5 = {}", calculator.apply(10, 5));
    println!("   -10 + 3 = {}", calculator.apply(-10, 3));
    println!();

    // Example 8: Combining multiple operations
    println!("8. Combining multiple operations:");
    let add = |x: i32, y: i32| x + y;

    // First calculate the sum, then choose different formatting based on whether it's even
    let sum_and_format = add.and_then(|n| {
        if n % 2 == 0 {
            format!("{} is even", n)
        } else {
            format!("{} is odd", n)
        }
    });

    println!("   3 + 5 = {}", sum_and_format.apply(3, 5));
    println!("   4 + 6 = {}", sum_and_format.apply(4, 6));

    println!("\n=== Demo completed ===");
}

examples/transformers/bi_transformer_demo.rs (line 63)

fn main() {
    println!("=== BiTransformer Demo ===\n");

    // 1. BoxBiTransformer - Single ownership
    println!("1. BoxBiTransformer - Single ownership");
    let add = BoxBiTransformer::new(|x: i32, y: i32| x + y);
    println!("   add.apply(20, 22) = {}", add.apply(20, 22));

    let multiply = BoxBiTransformer::new(|x: i32, y: i32| x * y);
    println!("   multiply.apply(6, 7) = {}", multiply.apply(6, 7));

    // Constant bi-transformer
    let constant = BoxBiTransformer::constant("hello");
    println!("   constant.apply(1, 2) = {}", constant.apply(1, 2));
    println!();

    // 2. ArcBiTransformer - Thread-safe, cloneable
    println!("2. ArcBiTransformer - Thread-safe, cloneable");
    let arc_add = ArcBiTransformer::new(|x: i32, y: i32| x + y);
    let arc_add_clone = arc_add.clone();

    println!("   arc_add.apply(10, 15) = {}", arc_add.apply(10, 15));
    println!(
        "   arc_add_clone.apply(5, 8) = {}",
        arc_add_clone.apply(5, 8)
    );
    println!();

    // 3. RcBiTransformer - Single-threaded, cloneable
    println!("3. RcBiTransformer - Single-threaded, cloneable");
    let rc_multiply = RcBiTransformer::new(|x: i32, y: i32| x * y);
    let rc_multiply_clone = rc_multiply.clone();

    println!("   rc_multiply.apply(3, 4) = {}", rc_multiply.apply(3, 4));
    println!(
        "   rc_multiply_clone.apply(5, 6) = {}",
        rc_multiply_clone.apply(5, 6)
    );
    println!();

    // 4. Conditional BiTransformer
    println!("4. Conditional BiTransformer");
    let add_if_positive = BoxBiTransformer::new(|x: i32, y: i32| x + y);
    let multiply_otherwise = BoxBiTransformer::new(|x: i32, y: i32| x * y);
    let conditional = add_if_positive
        .when(|x: &i32, y: &i32| *x > 0 && *y > 0)
        .or_else(multiply_otherwise);

    println!(
        "   conditional.apply(5, 3) = {} (both positive, add)",
        conditional.apply(5, 3)
    );
    println!(
        "   conditional.apply(-5, 3) = {} (not both positive, multiply)",
        conditional.apply(-5, 3)
    );
    println!();

    // 5. Working with different types
    println!("5. Working with different types");
    let format =
        BoxBiTransformer::new(|name: String, age: i32| format!("{} is {} years old", name, age));
    println!(
        "   format.apply(\"Alice\", 30) = {}",
        format.apply("Alice".to_string(), 30)
    );
    println!();

    // 6. Closure as BiTransformer
    println!("6. Closure as BiTransformer");
    let subtract = |x: i32, y: i32| x - y;
    println!("   subtract.apply(42, 10) = {}", subtract.apply(42, 10));
    println!();

    // 7. Conversion between types
    println!("7. Conversion between types");
    let box_add = BoxBiTransformer::new(|x: i32, y: i32| x + y);
    let rc_add = box_add.into_rc();
    println!("   Converted BoxBiTransformer to RcBiTransformer");
    println!("   rc_add.apply(7, 8) = {}", rc_add.apply(7, 8));
    println!();

    // 8. Safe division with Option
    println!("8. Safe division with Option");
    let safe_divide =
        BoxBiTransformer::new(|x: i32, y: i32| if y == 0 { None } else { Some(x / y) });
    println!(
        "   safe_divide.apply(42, 2) = {:?}",
        safe_divide.apply(42, 2)
    );
    println!(
        "   safe_divide.apply(42, 0) = {:?}",
        safe_divide.apply(42, 0)
    );
    println!();

    // 9. String concatenation
    println!("9. String concatenation");
    let concat = BoxBiTransformer::new(|s1: String, s2: String| format!("{}{}", s1, s2));
    println!(
        "   concat.apply(\"Hello\", \"World\") = {}",
        concat.apply("Hello".to_string(), "World".to_string())
    );
    println!();

    println!("=== Demo Complete ===");
}

examples/transformers/bi_transformer_and_then_demo.rs (line 157)

fn main() {
    println!("=== BiTransformer and_then Method Demo ===\n");

    // 1. BoxBiTransformer::and_then - Basic usage
    println!("1. BoxBiTransformer::and_then - Basic usage");
    let add = BoxBiTransformer::new(|x: i32, y: i32| x + y);
    let double = |x: i32| x * 2;
    let composed = add.and_then(double);
    println!("   (3 + 5) * 2 = {}", composed.apply(3, 5));
    println!();

    // 2. BoxBiTransformer::and_then - Chained calls
    println!("2. BoxBiTransformer::and_then - Chained calls");
    let multiply = BoxBiTransformer::new(|x: i32, y: i32| x * y);
    let add_ten = |x: i32| x + 10;
    let to_string = |x: i32| format!("Result: {}", x);
    let pipeline = multiply.and_then(add_ten).and_then(to_string);
    println!("   (6 * 7) + 10 = {}", pipeline.apply(6, 7));
    println!();

    // 3. ArcBiTransformer::and_then - Shared ownership
    println!("3. ArcBiTransformer::and_then - Shared ownership");
    let add_arc = ArcBiTransformer::new(|x: i32, y: i32| x + y);
    let triple = |x: i32| x * 3;
    let composed_arc = add_arc.and_then(triple);

    // Original bi-transformer is still available
    println!("   Original: 20 + 22 = {}", add_arc.apply(20, 22));
    println!("   Composed: (5 + 3) * 3 = {}", composed_arc.apply(5, 3));
    println!();

    // 4. ArcBiTransformer::and_then - Cloneable
    println!("4. ArcBiTransformer::and_then - Cloneable");
    let subtract = ArcBiTransformer::new(|x: i32, y: i32| x - y);
    let abs = |x: i32| x.abs();
    let composed_abs = subtract.and_then(abs);
    let cloned = composed_abs.clone();

    println!("   Original: |10 - 15| = {}", composed_abs.apply(10, 15));
    println!("   Cloned: |15 - 10| = {}", cloned.apply(15, 10));
    println!();

    // 5. RcBiTransformer::and_then - Single-threaded sharing
    println!("5. RcBiTransformer::and_then - Single-threaded sharing");
    let divide = RcBiTransformer::new(|x: i32, y: i32| x / y);
    let square = |x: i32| x * x;
    let composed_rc = divide.and_then(square);

    println!("   Original: 20 / 4 = {}", divide.apply(20, 4));
    println!("   Composed: (20 / 4)² = {}", composed_rc.apply(20, 4));
    println!();

    // 6. Type conversion example
    println!("6. Type conversion example");
    let concat = BoxBiTransformer::new(|s1: String, s2: String| format!("{} {}", s1, s2));
    let to_uppercase = |s: String| s.to_uppercase();
    let get_length = |s: String| s.len();

    let uppercase_pipeline = concat.and_then(to_uppercase);
    println!(
        "   \"hello\" + \"world\" -> uppercase: {}",
        uppercase_pipeline.apply("hello".to_string(), "world".to_string())
    );

    let concat2 = BoxBiTransformer::new(|s1: String, s2: String| format!("{} {}", s1, s2));
    let length_pipeline = concat2.and_then(get_length);
    println!(
        "   \"hello\" + \"world\" -> length: {}",
        length_pipeline.apply("hello".to_string(), "world".to_string())
    );
    println!();

    // 7. Real application: Calculator
    println!("7. Real application: Calculator");
    let calculate = BoxBiTransformer::new(|a: f64, b: f64| a + b);
    let round = |x: f64| x.round();
    let to_int = |x: f64| x as i32;

    let calculator = calculate.and_then(round).and_then(to_int);
    println!(
        "   3.7 + 4.8 -> round -> integer: {}",
        calculator.apply(3.7, 4.8)
    );
    println!();

    // 8. Error handling example
    println!("8. Error handling example");
    let safe_divide = BoxBiTransformer::new(|x: i32, y: i32| -> Result<i32, String> {
        if y == 0 {
            Err("Division by zero is not allowed".to_string())
        } else {
            Ok(x / y)
        }
    });

    let format_result = |res: Result<i32, String>| match res {
        Ok(v) => format!("Success: {}", v),
        Err(e) => format!("Error: {}", e),
    };

    let safe_calculator = safe_divide.and_then(format_result);
    println!("   10 / 2 = {}", safe_calculator.apply(10, 2));
    println!("   10 / 0 = {}", safe_calculator.apply(10, 0));
    println!();

    // 9. Complex data structures
    println!("9. Complex data structures");
    #[derive(Debug)]
    struct Point {
        x: i32,
        y: i32,
    }

    let create_point = BoxBiTransformer::new(|x: i32, y: i32| Point { x, y });
    let distance_from_origin = |p: Point| ((p.x * p.x + p.y * p.y) as f64).sqrt();
    let format_distance = |d: f64| format!("{:.2}", d);

    let point_processor = create_point
        .and_then(distance_from_origin)
        .and_then(format_distance);
    println!(
        "   Distance from point(3, 4) to origin: {}",
        point_processor.apply(3, 4)
    );
    println!();

    // 10. Combined usage with when
    println!("10. Combined usage with when");
    let add_when = BoxBiTransformer::new(|x: i32, y: i32| x + y);
    let multiply_when = BoxBiTransformer::new(|x: i32, y: i32| x * y);

    let conditional = add_when
        .when(|x: &i32, y: &i32| *x > 0 && *y > 0)
        .or_else(multiply_when);

    let double_result = |x: i32| x * 2;
    let final_transformer = conditional.and_then(double_result);

    println!(
        "   Add positive numbers then double: (5 + 3) * 2 = {}",
        final_transformer.apply(5, 3)
    );
    println!(
        "   Multiply negative numbers then double: (-5 * 3) * 2 = {}",
        final_transformer.apply(-5, 3)
    );

    println!("\n=== Demo completed ===");
}

Trait Implementations

impl<T, U, R> Debug for BoxConditionalBiTransformer<T, U, R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, U, R> Display for BoxConditionalBiTransformer<T, U, R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.