Struct BoxBiTransformer 

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

BoxBiTransformer - bi-transformer wrapper based on Box<dyn Fn>

A bi-transformer wrapper that provides single ownership with reusable transformation. The bi-transformer consumes both inputs and can be called multiple times.

Features

• Based on: Box<dyn Fn(T, U) -> R>
• Ownership: Single ownership, cannot be cloned
• Reusability: Can be called multiple times (each call consumes its inputs)
• Thread Safety: Not thread-safe (no Send + Sync requirement)

Implementations

impl<T, U, R> BoxBiTransformer<T, U, R>

pub fn new<F>(f: F) -> Self

where F: Fn(T, U) -> R + 'static,

Creates a new bi-transformer.

Wraps the provided closure in the appropriate smart pointer type for this bi-transformer implementation.

Examples found in repository

examples/transformers/bi_transformer_demo.rs (line 23)

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 27)

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 ===");
}

pub fn new_with_name<F>(name: &str, f: F) -> Self

where F: Fn(T, U) -> R + 'static,

Creates a new named bi-transformer.

Wraps the provided closure and assigns it a name, which is useful for debugging and logging purposes.

pub fn new_with_optional_name<F>(f: F, name: Option<String>) -> Self

where F: Fn(T, U) -> R + 'static,

Creates a new named bi-transformer with an optional name.

Wraps the provided closure and assigns it an optional name.

pub fn name(&self) -> Option<&str>

Gets the name of this bi-transformer.

Returns

Returns Some(&str) if a name was set, None otherwise.

pub fn set_name(&mut self, name: &str)

Sets the name of this bi-transformer.

Parameters

• name - The name to set for this bi-transformer

pub fn clear_name(&mut self)

Clears the name of this bi-transformer.

pub fn when<P>(self, predicate: P) -> BoxConditionalBiTransformer<T, U, R>

where T: 'static, U: 'static, R: 'static, P: BiPredicate<T, U> + 'static,

Creates a conditional two-parameter transformer that executes based on bi-predicate result.

Parameters

• predicate - The bi-predicate to determine whether to execute the transformation operation

Returns

Returns a conditional two-parameter transformer that only executes when the predicate returns true.

Examples

use qubit_function::transformers::*;

let bi_transformer = BoxBiTransformer::new({
    |key: String, value: i32| format!("{}: {}", key, value)
});

let conditional = bi_transformer
    .when(|key: &String, value: &i32| *value > 0)
    .or_else(|key: String, _value: i32| key);
assert_eq!(conditional.apply("test".to_string(), 5), "test: 5".to_string());  // transformed
assert_eq!(conditional.apply("test".to_string(), -1), "test".to_string());    // identity (key unchanged)

Examples found in repository

examples/transformers/bi_transformer_demo.rs (line 57)

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 149)

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 ===");
}

pub fn and_then<S, F>(self, after: F) -> BoxBiTransformer<T, U, S>

where T: 'static, U: 'static, R: 'static, S: 'static, F: Transformer<R, S> + 'static,

Chains execution with another two-parameter transformer, executing the current transformer first, then the subsequent transformer.

Parameters

• after - The subsequent two-parameter transformer to execute after the current transformer completes

Returns

Returns a new two-parameter transformer that executes the current transformer and the subsequent transformer in sequence.

Examples

use qubit_function::transformers::*;

let bi_transformer1 = BoxBiTransformer::new({
    |key: String, value: i32| (key, value + 1)
});

let bi_transformer2 = BoxTransformer::new({
    |value: (String, i32)| format!("{}: {}", value.0, value.1)
});

let chained = bi_transformer1.and_then(bi_transformer2);
let result = chained.apply("test".to_string(), 5);
assert_eq!(result, "test: 6"); // (value + 1) = 6

Examples found in repository

examples/transformers/bi_transformer_and_then_demo.rs (line 29)

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 ===");
}

impl<T, U, R> BoxBiTransformer<T, U, R>

pub fn constant(value: R) -> BoxBiTransformer<T, U, R>

where R: Clone + 'static,

Creates a constant bi-transformer

Examples

/// rust /// use qubit_function::{BoxBiTransformer, BiTransformer}; /// /// let constant = BoxBiTransformer::constant("hello"); /// assert_eq!(constant.apply(123, 456), "hello"); ///

Examples found in repository

examples/transformers/bi_transformer_demo.rs (line 30)

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 ===");
}

Trait Implementations

impl<T, U, R> BiTransformer<T, U, R> for BoxBiTransformer<T, U, R>

fn apply(&self, first: T, second: U) -> R

Transforms two input values to produce an output value

fn into_box(self) -> BoxBiTransformer<T, U, R>

Converts to BoxBiTransformer

fn into_rc(self) -> RcBiTransformer<T, U, R>

where Self: 'static,

Converts to RcBiTransformer

fn into_fn(self) -> impl Fn(T, U) -> R

Converts bi-transformer to a closure

fn into_once(self) -> BoxBiTransformerOnce<T, U, R>

where Self: 'static,

Convert to BiTransformerOnce

fn into_arc(self) -> ArcBiTransformer<T, U, R>

where Self: Sized + Send + Sync + 'static,

Converts to ArcBiTransformer

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.