Struct BoxBiTransformerOnce 

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

BoxBiTransformerOnce - consuming bi-transformer wrapper based on Box<dyn FnOnce>

A bi-transformer wrapper that provides single ownership with one-time use semantics. Consumes self and both input values.

Features

• Based on: Box<dyn FnOnce(T, U) -> R>
• Ownership: Single ownership, cannot be cloned
• Reusability: Can only be called once (consumes self and inputs)
• Thread Safety: Not thread-safe (no Send + Sync requirement)

Author

Haixing Hu

Implementations

impl<T, U, R> BoxBiTransformerOnce<T, U, R>

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

where F: FnOnce(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_once_and_then_demo.rs (line 23)

fn main() {
    println!("=== BoxBiTransformerOnce and_then Method Example ===\n");

    // Example 1: Basic and_then usage
    println!("Example 1: Basic and_then usage");
    let add = BoxBiTransformerOnce::new(|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);
    assert_eq!(result, 16);
    println!();

    // Example 2: Type conversion
    println!("Example 2: Type conversion");
    let add2 = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let to_string = |x: i32| x.to_string();
    let composed2 = add2.and_then(to_string);
    let result2 = composed2.apply(20, 22);
    println!("  (20 + 22).to_string() = \"{}\"", result2);
    assert_eq!(result2, "42");
    println!();

    // Example 3: Multi-level chained composition
    println!("Example 3: Multi-level chained composition");
    let add3 = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let double3 = |x: i32| x * 2;
    let to_string3 = |x: i32| format!("Result: {}", x);
    let composed3 = add3.and_then(double3).and_then(to_string3);
    let result3 = composed3.apply(3, 5);
    println!("  (3 + 5) * 2 -> \"{}\"", result3);
    assert_eq!(result3, "Result: 16");
    println!();

    // Example 4: String operations
    println!("Example 4: String operations");
    let concat = BoxBiTransformerOnce::new(|x: String, y: String| format!("{} {}", x, y));
    let uppercase = |s: String| s.to_uppercase();
    let composed4 = concat.and_then(uppercase);
    let result4 = composed4.apply("hello".to_string(), "world".to_string());
    println!("  \"hello\" + \"world\" -> uppercase = \"{}\"", result4);
    assert_eq!(result4, "HELLO WORLD");
    println!();

    // Example 5: Mathematical calculation chain
    println!("Example 5: Mathematical calculation chain");
    let multiply = BoxBiTransformerOnce::new(|x: i32, y: i32| x * y);
    let to_float = |x: i32| x as f64 / 2.0;
    let composed5 = multiply.and_then(to_float);
    let result5 = composed5.apply(6, 7);
    println!("  (6 * 7) / 2.0 = {}", result5);
    assert!((result5 - 21.0).abs() < 1e-10);
    println!();

    // Example 6: Complex business logic
    println!("Example 6: Complex business logic");
    let calculate_total =
        BoxBiTransformerOnce::new(|price: f64, quantity: i32| price * quantity as f64);
    let apply_discount = |total: f64| {
        if total > 100.0 {
            total * 0.9 // 10% discount
        } else {
            total
        }
    };
    let format_price = |total: f64| format!("${:.2}", total);
    let composed6 = calculate_total
        .and_then(apply_discount)
        .and_then(format_price);
    let result6 = composed6.apply(15.5, 8);
    println!("  Price: $15.5, Quantity: 8");
    println!("  Total price (with discount): {}", result6);
    assert_eq!(result6, "$111.60");
    println!();

    println!("=== All examples executed successfully! ===");
}

examples/transformers/bi_transformer_once_demo.rs (line 27)

fn main() {
    println!("=== BiTransformerOnce Examples ===\n");

    // Example 1: Basic usage with closure
    println!("1. Basic usage with closure:");
    let add = |x: i32, y: i32| x + y;
    let result = add.apply(20, 22);
    println!("   20 + 22 = {}", result);

    // Example 2: BoxBiTransformerOnce with new
    println!("\n2. BoxBiTransformerOnce with new:");
    let multiply = BoxBiTransformerOnce::new(|x: i32, y: i32| x * y);
    println!("   6 * 7 = {}", multiply.apply(6, 7));

    // Example 3: Constant transformer
    println!("\n3. Constant transformer:");
    let constant = BoxBiTransformerOnce::constant("hello");
    println!("   constant(123, 456) = {}", constant.apply(123, 456));

    // Example 4: Consuming owned values
    println!("\n4. Consuming owned values:");
    let concat = BoxBiTransformerOnce::new(|x: String, y: String| format!("{} {}", x, y));
    let s1 = String::from("hello");
    let s2 = String::from("world");
    let result = concat.apply(s1, s2);
    println!("   concat('hello', 'world') = {}", result);

    // Example 5: Conditional transformation with when/or_else
    println!("\n5. Conditional transformation (positive numbers):");
    let add = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let multiply = BoxBiTransformerOnce::new(|x: i32, y: i32| x * y);
    let conditional = add
        .when(|x: &i32, y: &i32| *x > 0 && *y > 0)
        .or_else(multiply);
    println!("   conditional(5, 3) = {} (add)", conditional.apply(5, 3));

    println!("\n6. Conditional transformation (negative numbers):");
    let add2 = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let multiply2 = BoxBiTransformerOnce::new(|x: i32, y: i32| x * y);
    let conditional2 = add2
        .when(|x: &i32, y: &i32| *x > 0 && *y > 0)
        .or_else(multiply2);
    println!(
        "   conditional(-5, 3) = {} (multiply)",
        conditional2.apply(-5, 3)
    );

    // Example 7: Conditional with closure in or_else
    println!("\n7. Conditional with closure in or_else:");
    let add3 = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let conditional3 = add3
        .when(|x: &i32, y: &i32| *x > 0 && *y > 0)
        .or_else(|x: i32, y: i32| x * y);
    println!("   conditional(4, 6) = {}", conditional3.apply(4, 6));

    // Example 8: Merging vectors
    println!("\n8. Merging vectors:");
    let merge = BoxBiTransformerOnce::new(|mut x: Vec<i32>, y: Vec<i32>| {
        x.extend(y);
        x
    });
    let v1 = vec![1, 2, 3];
    let v2 = vec![4, 5, 6];
    let result = merge.apply(v1, v2);
    println!("   merge([1, 2, 3], [4, 5, 6]) = {:?}", result);

    // Example 9: Complex transformation with calculation
    println!("\n9. Complex transformation with calculation:");
    let calculate = BoxBiTransformerOnce::new(|x: i32, y: i32| {
        let sum = x + y;
        let product = x * y;
        (sum, product)
    });
    let (sum, product) = calculate.apply(5, 3);
    println!("   calculate(5, 3) = (sum: {}, product: {})", sum, product);

    // Example 10: String manipulation
    println!("\n10. String manipulation:");
    let process = BoxBiTransformerOnce::new(|x: String, y: String| {
        format!("{} {} {}", x.to_uppercase(), "and", y.to_lowercase())
    });
    println!(
        "   process('Hello', 'WORLD') = {}",
        process.apply("Hello".to_string(), "WORLD".to_string())
    );

    // Example 11: Converting to function
    println!("\n11. Converting to function:");
    let add4 = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let f = add4.into_fn();
    println!("   f(10, 20) = {}", f(10, 20));

    // Example 12: Converting to box (zero-cost)
    println!("\n12. Converting to box (zero-cost):");
    let add5 = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let boxed = add5.into_box();
    println!("   boxed(15, 25) = {}", boxed.apply(15, 25));

    println!("\n=== All examples completed successfully! ===");
}

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

where F: FnOnce(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: FnOnce(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) -> BoxConditionalBiTransformerOnce<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_once_demo.rs (line 48)

fn main() {
    println!("=== BiTransformerOnce Examples ===\n");

    // Example 1: Basic usage with closure
    println!("1. Basic usage with closure:");
    let add = |x: i32, y: i32| x + y;
    let result = add.apply(20, 22);
    println!("   20 + 22 = {}", result);

    // Example 2: BoxBiTransformerOnce with new
    println!("\n2. BoxBiTransformerOnce with new:");
    let multiply = BoxBiTransformerOnce::new(|x: i32, y: i32| x * y);
    println!("   6 * 7 = {}", multiply.apply(6, 7));

    // Example 3: Constant transformer
    println!("\n3. Constant transformer:");
    let constant = BoxBiTransformerOnce::constant("hello");
    println!("   constant(123, 456) = {}", constant.apply(123, 456));

    // Example 4: Consuming owned values
    println!("\n4. Consuming owned values:");
    let concat = BoxBiTransformerOnce::new(|x: String, y: String| format!("{} {}", x, y));
    let s1 = String::from("hello");
    let s2 = String::from("world");
    let result = concat.apply(s1, s2);
    println!("   concat('hello', 'world') = {}", result);

    // Example 5: Conditional transformation with when/or_else
    println!("\n5. Conditional transformation (positive numbers):");
    let add = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let multiply = BoxBiTransformerOnce::new(|x: i32, y: i32| x * y);
    let conditional = add
        .when(|x: &i32, y: &i32| *x > 0 && *y > 0)
        .or_else(multiply);
    println!("   conditional(5, 3) = {} (add)", conditional.apply(5, 3));

    println!("\n6. Conditional transformation (negative numbers):");
    let add2 = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let multiply2 = BoxBiTransformerOnce::new(|x: i32, y: i32| x * y);
    let conditional2 = add2
        .when(|x: &i32, y: &i32| *x > 0 && *y > 0)
        .or_else(multiply2);
    println!(
        "   conditional(-5, 3) = {} (multiply)",
        conditional2.apply(-5, 3)
    );

    // Example 7: Conditional with closure in or_else
    println!("\n7. Conditional with closure in or_else:");
    let add3 = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let conditional3 = add3
        .when(|x: &i32, y: &i32| *x > 0 && *y > 0)
        .or_else(|x: i32, y: i32| x * y);
    println!("   conditional(4, 6) = {}", conditional3.apply(4, 6));

    // Example 8: Merging vectors
    println!("\n8. Merging vectors:");
    let merge = BoxBiTransformerOnce::new(|mut x: Vec<i32>, y: Vec<i32>| {
        x.extend(y);
        x
    });
    let v1 = vec![1, 2, 3];
    let v2 = vec![4, 5, 6];
    let result = merge.apply(v1, v2);
    println!("   merge([1, 2, 3], [4, 5, 6]) = {:?}", result);

    // Example 9: Complex transformation with calculation
    println!("\n9. Complex transformation with calculation:");
    let calculate = BoxBiTransformerOnce::new(|x: i32, y: i32| {
        let sum = x + y;
        let product = x * y;
        (sum, product)
    });
    let (sum, product) = calculate.apply(5, 3);
    println!("   calculate(5, 3) = (sum: {}, product: {})", sum, product);

    // Example 10: String manipulation
    println!("\n10. String manipulation:");
    let process = BoxBiTransformerOnce::new(|x: String, y: String| {
        format!("{} {} {}", x.to_uppercase(), "and", y.to_lowercase())
    });
    println!(
        "   process('Hello', 'WORLD') = {}",
        process.apply("Hello".to_string(), "WORLD".to_string())
    );

    // Example 11: Converting to function
    println!("\n11. Converting to function:");
    let add4 = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let f = add4.into_fn();
    println!("   f(10, 20) = {}", f(10, 20));

    // Example 12: Converting to box (zero-cost)
    println!("\n12. Converting to box (zero-cost):");
    let add5 = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let boxed = add5.into_box();
    println!("   boxed(15, 25) = {}", boxed.apply(15, 25));

    println!("\n=== All examples completed successfully! ===");
}

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

where T: 'static, U: 'static, R: 'static, S: 'static, F: TransformerOnce<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_once_and_then_demo.rs (line 25)

fn main() {
    println!("=== BoxBiTransformerOnce and_then Method Example ===\n");

    // Example 1: Basic and_then usage
    println!("Example 1: Basic and_then usage");
    let add = BoxBiTransformerOnce::new(|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);
    assert_eq!(result, 16);
    println!();

    // Example 2: Type conversion
    println!("Example 2: Type conversion");
    let add2 = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let to_string = |x: i32| x.to_string();
    let composed2 = add2.and_then(to_string);
    let result2 = composed2.apply(20, 22);
    println!("  (20 + 22).to_string() = \"{}\"", result2);
    assert_eq!(result2, "42");
    println!();

    // Example 3: Multi-level chained composition
    println!("Example 3: Multi-level chained composition");
    let add3 = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let double3 = |x: i32| x * 2;
    let to_string3 = |x: i32| format!("Result: {}", x);
    let composed3 = add3.and_then(double3).and_then(to_string3);
    let result3 = composed3.apply(3, 5);
    println!("  (3 + 5) * 2 -> \"{}\"", result3);
    assert_eq!(result3, "Result: 16");
    println!();

    // Example 4: String operations
    println!("Example 4: String operations");
    let concat = BoxBiTransformerOnce::new(|x: String, y: String| format!("{} {}", x, y));
    let uppercase = |s: String| s.to_uppercase();
    let composed4 = concat.and_then(uppercase);
    let result4 = composed4.apply("hello".to_string(), "world".to_string());
    println!("  \"hello\" + \"world\" -> uppercase = \"{}\"", result4);
    assert_eq!(result4, "HELLO WORLD");
    println!();

    // Example 5: Mathematical calculation chain
    println!("Example 5: Mathematical calculation chain");
    let multiply = BoxBiTransformerOnce::new(|x: i32, y: i32| x * y);
    let to_float = |x: i32| x as f64 / 2.0;
    let composed5 = multiply.and_then(to_float);
    let result5 = composed5.apply(6, 7);
    println!("  (6 * 7) / 2.0 = {}", result5);
    assert!((result5 - 21.0).abs() < 1e-10);
    println!();

    // Example 6: Complex business logic
    println!("Example 6: Complex business logic");
    let calculate_total =
        BoxBiTransformerOnce::new(|price: f64, quantity: i32| price * quantity as f64);
    let apply_discount = |total: f64| {
        if total > 100.0 {
            total * 0.9 // 10% discount
        } else {
            total
        }
    };
    let format_price = |total: f64| format!("${:.2}", total);
    let composed6 = calculate_total
        .and_then(apply_discount)
        .and_then(format_price);
    let result6 = composed6.apply(15.5, 8);
    println!("  Price: $15.5, Quantity: 8");
    println!("  Total price (with discount): {}", result6);
    assert_eq!(result6, "$111.60");
    println!();

    println!("=== All examples executed successfully! ===");
}

impl<T, U, R> BoxBiTransformerOnce<T, U, R>

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

where R: Clone + 'static,

Creates a constant bi-transformer

Examples

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

Examples found in repository

examples/transformers/bi_transformer_once_demo.rs (line 32)

fn main() {
    println!("=== BiTransformerOnce Examples ===\n");

    // Example 1: Basic usage with closure
    println!("1. Basic usage with closure:");
    let add = |x: i32, y: i32| x + y;
    let result = add.apply(20, 22);
    println!("   20 + 22 = {}", result);

    // Example 2: BoxBiTransformerOnce with new
    println!("\n2. BoxBiTransformerOnce with new:");
    let multiply = BoxBiTransformerOnce::new(|x: i32, y: i32| x * y);
    println!("   6 * 7 = {}", multiply.apply(6, 7));

    // Example 3: Constant transformer
    println!("\n3. Constant transformer:");
    let constant = BoxBiTransformerOnce::constant("hello");
    println!("   constant(123, 456) = {}", constant.apply(123, 456));

    // Example 4: Consuming owned values
    println!("\n4. Consuming owned values:");
    let concat = BoxBiTransformerOnce::new(|x: String, y: String| format!("{} {}", x, y));
    let s1 = String::from("hello");
    let s2 = String::from("world");
    let result = concat.apply(s1, s2);
    println!("   concat('hello', 'world') = {}", result);

    // Example 5: Conditional transformation with when/or_else
    println!("\n5. Conditional transformation (positive numbers):");
    let add = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let multiply = BoxBiTransformerOnce::new(|x: i32, y: i32| x * y);
    let conditional = add
        .when(|x: &i32, y: &i32| *x > 0 && *y > 0)
        .or_else(multiply);
    println!("   conditional(5, 3) = {} (add)", conditional.apply(5, 3));

    println!("\n6. Conditional transformation (negative numbers):");
    let add2 = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let multiply2 = BoxBiTransformerOnce::new(|x: i32, y: i32| x * y);
    let conditional2 = add2
        .when(|x: &i32, y: &i32| *x > 0 && *y > 0)
        .or_else(multiply2);
    println!(
        "   conditional(-5, 3) = {} (multiply)",
        conditional2.apply(-5, 3)
    );

    // Example 7: Conditional with closure in or_else
    println!("\n7. Conditional with closure in or_else:");
    let add3 = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let conditional3 = add3
        .when(|x: &i32, y: &i32| *x > 0 && *y > 0)
        .or_else(|x: i32, y: i32| x * y);
    println!("   conditional(4, 6) = {}", conditional3.apply(4, 6));

    // Example 8: Merging vectors
    println!("\n8. Merging vectors:");
    let merge = BoxBiTransformerOnce::new(|mut x: Vec<i32>, y: Vec<i32>| {
        x.extend(y);
        x
    });
    let v1 = vec![1, 2, 3];
    let v2 = vec![4, 5, 6];
    let result = merge.apply(v1, v2);
    println!("   merge([1, 2, 3], [4, 5, 6]) = {:?}", result);

    // Example 9: Complex transformation with calculation
    println!("\n9. Complex transformation with calculation:");
    let calculate = BoxBiTransformerOnce::new(|x: i32, y: i32| {
        let sum = x + y;
        let product = x * y;
        (sum, product)
    });
    let (sum, product) = calculate.apply(5, 3);
    println!("   calculate(5, 3) = (sum: {}, product: {})", sum, product);

    // Example 10: String manipulation
    println!("\n10. String manipulation:");
    let process = BoxBiTransformerOnce::new(|x: String, y: String| {
        format!("{} {} {}", x.to_uppercase(), "and", y.to_lowercase())
    });
    println!(
        "   process('Hello', 'WORLD') = {}",
        process.apply("Hello".to_string(), "WORLD".to_string())
    );

    // Example 11: Converting to function
    println!("\n11. Converting to function:");
    let add4 = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let f = add4.into_fn();
    println!("   f(10, 20) = {}", f(10, 20));

    // Example 12: Converting to box (zero-cost)
    println!("\n12. Converting to box (zero-cost):");
    let add5 = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
    let boxed = add5.into_box();
    println!("   boxed(15, 25) = {}", boxed.apply(15, 25));

    println!("\n=== All examples completed successfully! ===");
}

Trait Implementations

impl<T, U, R> BiTransformerOnce<T, U, R> for BoxBiTransformerOnce<T, U, R>

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

Transforms two input values, consuming self and both inputs

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

Converts to BoxBiTransformerOnce

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

Converts bi-transformer to a closure

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.