Struct RcBiTransformer 

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

RcBiTransformer - single-threaded bi-transformer wrapper

A single-threaded, clonable bi-transformer wrapper optimized for scenarios that require sharing without thread-safety overhead.

Features

• Based on: Rc<dyn Fn(T, U) -> R>
• Ownership: Shared ownership via reference counting (non-atomic)
• Reusability: Can be called multiple times (each call consumes its inputs)
• Thread Safety: Not thread-safe (no Send + Sync)
• Clonable: Cheap cloning via Rc::clone

Author

Hu Haixing

Implementations

impl<T, U, R> RcBiTransformer<T, U, R>

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

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

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

Creates a new RcBiTransformer

Parameters

• f - The closure or function to wrap

Examples

use prism3_function::{RcBiTransformer, BiTransformer};

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

Examples found in repository

examples/bi_transformer_demo.rs (line 45)

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.transform(20, 22) = {}", add.transform(20, 22));

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

    // Constant bi-transformer
    let constant = BoxBiTransformer::constant("hello");
    println!("   constant.transform(1, 2) = {}", constant.transform(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.transform(10, 15) = {}",
        arc_add.transform(10, 15)
    );
    println!(
        "   arc_add_clone.transform(5, 8) = {}",
        arc_add_clone.transform(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.transform(3, 4) = {}",
        rc_multiply.transform(3, 4)
    );
    println!(
        "   rc_multiply_clone.transform(5, 6) = {}",
        rc_multiply_clone.transform(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.transform(5, 3) = {} (both positive, add)",
        conditional.transform(5, 3)
    );
    println!(
        "   conditional.transform(-5, 3) = {} (not both positive, multiply)",
        conditional.transform(-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.transform(\"Alice\", 30) = {}",
        format.transform("Alice".to_string(), 30)
    );
    println!();

    // 6. Closure as BiTransformer
    println!("6. Closure as BiTransformer");
    let subtract = |x: i32, y: i32| x - y;
    println!(
        "   subtract.transform(42, 10) = {}",
        subtract.transform(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.transform(7, 8) = {}", rc_add.transform(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.transform(42, 2) = {:?}",
        safe_divide.transform(42, 2)
    );
    println!(
        "   safe_divide.transform(42, 0) = {:?}",
        safe_divide.transform(42, 0)
    );
    println!();

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

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

examples/bi_transformer_and_then_demo.rs (line 69)

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.transform(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.transform(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.transform(20, 22));
    println!(
        "   Composed: (5 + 3) * 3 = {}",
        composed_arc.transform(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.transform(10, 15)
    );
    println!("   Cloned: |15 - 10| = {}", cloned.transform(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.transform(20, 4));
    println!("   Composed: (20 / 4)² = {}", composed_rc.transform(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.transform("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.transform("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.transform(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.transform(10, 2));
    println!("   10 / 0 = {}", safe_calculator.transform(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.transform(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.transform(5, 3)
    );
    println!(
        "   Multiply negative numbers then double: (-5 * 3) * 2 = {}",
        final_transformer.transform(-5, 3)
    );

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

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

where S: 'static, F: Transformer<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. Uses &self, so original bi-transformer remains usable.

Type Parameters

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

Parameters

• after - The transformer to apply after self. Note: This parameter is passed by value and will transfer ownership. If you need to preserve the original transformer, clone it first (if it implements Clone). Can be:
  • A closure: |x: R| -> S
  • A function pointer: fn(R) -> S
  • A BoxTransformer<R, S>
  • An RcTransformer<R, S> (will be moved)
  • An ArcTransformer<R, S>
  • Any type implementing Transformer<R, S>

Returns

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

Examples

Direct value passing (ownership transfer)

use prism3_function::{BiTransformer, RcBiTransformer, RcTransformer};

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

// double is moved here
let composed = add.and_then(double);

// Original add bi-transformer still usable (uses &self)
assert_eq!(add.transform(20, 22), 42);
assert_eq!(composed.transform(3, 5), 16); // (3 + 5) * 2
// double.transform(10); // Would not compile - moved

Preserving original with clone

use prism3_function::{BiTransformer, RcBiTransformer, RcTransformer};

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

// Clone to preserve original
let composed = add.and_then(double.clone());
assert_eq!(composed.transform(3, 5), 16); // (3 + 5) * 2

// Both originals still usable
assert_eq!(add.transform(20, 22), 42);
assert_eq!(double.transform(10), 20);

Examples found in repository

examples/bi_transformer_and_then_demo.rs (line 71)

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.transform(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.transform(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.transform(20, 22));
    println!(
        "   Composed: (5 + 3) * 3 = {}",
        composed_arc.transform(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.transform(10, 15)
    );
    println!("   Cloned: |15 - 10| = {}", cloned.transform(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.transform(20, 4));
    println!("   Composed: (20 / 4)² = {}", composed_rc.transform(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.transform("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.transform("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.transform(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.transform(10, 2));
    println!("   10 / 0 = {}", safe_calculator.transform(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.transform(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.transform(5, 3)
    );
    println!(
        "   Multiply negative numbers then double: (-5 * 3) * 2 = {}",
        final_transformer.transform(-5, 3)
    );

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

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

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

Creates a conditional bi-transformer (single-threaded shared version)

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 RcConditionalBiTransformer<T, U, R>

Examples

Basic usage with or_else

use prism3_function::{BiTransformer, RcBiTransformer};

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

let conditional_clone = conditional.clone();

assert_eq!(conditional.transform(5, 3), 8);
assert_eq!(conditional_clone.transform(-5, 3), -15);

Preserving bi-predicate with clone

use prism3_function::{BiTransformer, RcBiTransformer, RcBiPredicate};

let add = RcBiTransformer::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(RcBiTransformer::new(|x, y| x * y));

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

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

impl<T, U, R> RcBiTransformer<T, U, R>

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

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

Creates a constant bi-transformer

Examples

use prism3_function::{RcBiTransformer, BiTransformer};

let constant = RcBiTransformer::constant("hello");
assert_eq!(constant.transform(123, 456), "hello");

Trait Implementations

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

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

Transforms two input values to produce an output value

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

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

Converts to BoxBiTransformer

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

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

Converts to RcBiTransformer

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

where Self: Send + Sync, T: Send + Sync + 'static, U: Send + Sync + 'static, R: Send + Sync + 'static,

Converts to ArcBiTransformer

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

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

Converts bi-transformer to a closure

impl<T, U, R> Clone for RcBiTransformer<T, U, R>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.