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

Hu Haixing

Implementations

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

where T: 'static, U: 'static, R: 'static,

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

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

Creates a new BoxBiTransformerOnce

Parameters

• f - The closure or function to wrap

Examples

use prism3_function::{BoxBiTransformerOnce, BiTransformerOnce};

let add = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
assert_eq!(add.apply_once(20, 22), 42);

Examples found in repository

examples/bi_transformer_once_and_then_demo.rs (line 20)

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_once(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_once(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_once(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_once("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_once(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_once(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/bi_transformer_once_demo.rs (line 24)

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_once(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_once(6, 7));

    // Example 3: Constant transformer
    println!("\n3. Constant transformer:");
    let constant = BoxBiTransformerOnce::constant("hello");
    println!("   constant(123, 456) = {}", constant.apply_once(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_once(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_once(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_once(-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_once(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_once(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_once(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_once("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_once();
    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_once();
    println!("   boxed(15, 25) = {}", boxed.apply_once(15, 25));

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

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

where S: 'static, F: TransformerOnce<R, S> + 'static,

Chain composition - applies self first, then after

Creates a new bi-transformer that applies this bi-transformer first, then applies the after transformer to the result. Consumes self and returns a new BoxBiTransformerOnce.

Type Parameters

• S - The output type of the after transformer
• F - The type of the after transformer (must implement TransformerOnce<R, S>)

Parameters

• after - The transformer to apply after self. Note: This parameter is passed by value and will transfer ownership. Since BoxBiTransformerOnce cannot be cloned, the parameter will be consumed. Can be:
  • A closure: |x: R| -> S
  • A function pointer: fn(R) -> S
  • A BoxTransformerOnce<R, S>
  • Any type implementing TransformerOnce<R, S>

Returns

A new BoxBiTransformerOnce<T, U, S> representing the composition

Examples

use prism3_function::{BiTransformerOnce, BoxBiTransformerOnce};

let add = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
let double = |x: i32| x * 2;

// Both add and double are moved and consumed
let composed = add.and_then(double);
assert_eq!(composed.apply_once(3, 5), 16); // (3 + 5) * 2
// add.apply_once(1, 2); // Would not compile - moved
// double(10); // Would not compile - moved

Examples found in repository

examples/bi_transformer_once_and_then_demo.rs (line 22)

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

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

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

Creates a conditional bi-transformer

Returns a bi-transformer that only executes when a bi-predicate is satisfied. You must call or_else() to provide an alternative bi-transformer.

Parameters

• predicate - The condition to check. Note: This parameter is passed by value and will transfer ownership. If you need to preserve the original bi-predicate, clone it first (if it implements Clone). Can be:
  • A closure: |x: &T, y: &U| -> bool
  • A function pointer: fn(&T, &U) -> bool
  • A BoxBiPredicate<T, U>
  • An RcBiPredicate<T, U>
  • An ArcBiPredicate<T, U>
  • Any type implementing BiPredicate<T, U>

Returns

Returns BoxConditionalBiTransformerOnce<T, U, R>

Examples

Basic usage with or_else

use prism3_function::{BiTransformerOnce, BoxBiTransformerOnce};

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);
assert_eq!(conditional.apply_once(5, 3), 8);

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);
assert_eq!(conditional2.apply_once(-5, 3), -15);

Preserving bi-predicate with clone

use prism3_function::{BiTransformerOnce, BoxBiTransformerOnce, RcBiPredicate};

let add = BoxBiTransformerOnce::new(|x: i32, y: i32| x + y);
let both_positive = RcBiPredicate::new(|x: &i32, y: &i32|
    *x > 0 && *y > 0);

// Clone to preserve original bi-predicate
let conditional = add.when(both_positive.clone())
    .or_else(BoxBiTransformerOnce::new(|x, y| x * y));

assert_eq!(conditional.apply_once(5, 3), 8);

// Original bi-predicate still usable
assert!(both_positive.test(&5, &3));

Examples found in repository

examples/bi_transformer_once_demo.rs (line 45)

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_once(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_once(6, 7));

    // Example 3: Constant transformer
    println!("\n3. Constant transformer:");
    let constant = BoxBiTransformerOnce::constant("hello");
    println!("   constant(123, 456) = {}", constant.apply_once(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_once(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_once(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_once(-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_once(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_once(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_once(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_once("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_once();
    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_once();
    println!("   boxed(15, 25) = {}", boxed.apply_once(15, 25));

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

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

where T: 'static, U: 'static, R: Clone + 'static,

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

Creates a constant bi-transformer

Examples

use prism3_function::{BoxBiTransformerOnce, BiTransformerOnce};

let constant = BoxBiTransformerOnce::constant("hello");
assert_eq!(constant.apply_once(123, 456), "hello");

Examples found in repository

examples/bi_transformer_once_demo.rs (line 29)

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_once(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_once(6, 7));

    // Example 3: Constant transformer
    println!("\n3. Constant transformer:");
    let constant = BoxBiTransformerOnce::constant("hello");
    println!("   constant(123, 456) = {}", constant.apply_once(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_once(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_once(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_once(-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_once(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_once(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_once(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_once("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_once();
    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_once();
    println!("   boxed(15, 25) = {}", boxed.apply_once(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_once(self, first: T, second: U) -> R

Transforms two input values, consuming self and both inputs

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

where T: 'static, U: 'static, R: 'static,

Converts to BoxBiTransformerOnce

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

where T: 'static, U: 'static, R: 'static,

Converts bi-transformer to a closure