Struct BoxTransformer 

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

BoxTransformer - transformer wrapper based on Box<dyn Fn>

A transformer wrapper that provides single ownership with reusable transformation. The transformer consumes the input and can be called multiple times.

Features

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

Implementations

impl<T, R> BoxTransformer<T, R>

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

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

Creates a new transformer.

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

Examples found in repository

examples/transformers/transformer_once_demo.rs (line 30)

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

    // BoxTransformer TransformerOnce demonstration
    println!("1. BoxTransformer TransformerOnce demonstration:");
    let double = BoxTransformer::new(|x: i32| x * 2);
    let result = double.apply(21);
    println!("   double.apply(21) = {}", result);

    // Convert to BoxTransformerOnce
    let double = BoxTransformer::new(|x: i32| x * 2);
    let boxed = double.into_box();
    let result = boxed.apply(21);
    println!("   double.into_box().apply(21) = {}", result);

    // Convert to function
    let double = BoxTransformer::new(|x: i32| x * 2);
    let func = double.into_fn();
    let result = func(21);
    println!("   double.into_fn()(21) = {}", result);

    println!();

    // RcTransformer TransformerOnce demonstration
    println!("2. RcTransformer TransformerOnce demonstration:");
    let uppercase = RcTransformer::new(|s: String| s.to_uppercase());
    let result = uppercase.apply("hello".to_string());
    println!("   uppercase.apply(\"hello\") = {}", result);

    // Use after cloning
    let uppercase = RcTransformer::new(|s: String| s.to_uppercase());
    let uppercase_clone = uppercase.clone();
    let result1 = uppercase.apply("world".to_string());
    let result2 = uppercase_clone.apply("rust".to_string());
    println!("   uppercase.apply(\"world\") = {}", result1);
    println!("   uppercase_clone.apply(\"rust\") = {}", result2);

    println!();

    // ArcTransformer TransformerOnce demonstration
    println!("3. ArcTransformer TransformerOnce demonstration:");
    let parse_and_double = ArcTransformer::new(|s: String| s.parse::<i32>().unwrap_or(0) * 2);
    let result = parse_and_double.apply("21".to_string());
    println!("   parse_and_double.apply(\"21\") = {}", result);

    // Thread safety demonstration
    println!("4. ArcTransformer thread safety demonstration:");
    let double = ArcTransformer::new(|x: i32| x * 2);
    let double_arc = Arc::new(double);
    let _double_clone = Arc::clone(&double_arc);

    let handle = thread::spawn(move || {
        // Create a new transformer in the thread to demonstrate thread safety
        let new_double = ArcTransformer::new(|x: i32| x * 2);
        new_double.apply(21)
    });

    let result = handle.join().expect("thread should not panic");
    println!("   Executed in thread: new_double.apply(21) = {}", result);

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

examples/transformers/transformer_demo.rs (line 27)

fn main() {
    println!("=== Transformer Demo - Type Transformation (consumes T) ===\n");

    // ====================================================================
    // Part 1: BoxTransformer - Single ownership, reusable
    // ====================================================================
    println!("--- BoxTransformer ---");
    let double = BoxTransformer::new(|x: i32| x * 2);
    println!("double.apply(21) = {}", double.apply(21));
    println!("double.apply(42) = {}", double.apply(42));

    // Identity and constant
    let identity = BoxTransformer::<i32, i32>::identity();
    println!("identity.apply(42) = {}", identity.apply(42));

    let constant = BoxTransformer::constant("hello");
    println!("constant.apply(123) = {}", constant.apply(123));
    println!();

    // ====================================================================
    // Part 2: ArcTransformer - Thread-safe, cloneable
    // ====================================================================
    println!("--- ArcTransformer ---");
    let arc_double = ArcTransformer::new(|x: i32| x * 2);
    let arc_cloned = arc_double.clone();

    println!("arc_double.apply(21) = {}", arc_double.apply(21));
    println!("arc_cloned.apply(42) = {}", arc_cloned.apply(42));

    // Multi-threaded usage
    let for_thread = arc_double.clone();
    let handle = thread::spawn(move || for_thread.apply(100));
    println!("In main thread: arc_double.apply(50) = {}", arc_double.apply(50));
    println!(
        "In child thread: result = {}",
        handle.join().expect("thread should not panic")
    );
    println!();

    // ====================================================================
    // Part 3: RcTransformer - Single-threaded, cloneable
    // ====================================================================
    println!("--- RcTransformer ---");
    let rc_double = RcTransformer::new(|x: i32| x * 2);
    let rc_cloned = rc_double.clone();

    println!("rc_double.apply(21) = {}", rc_double.apply(21));
    println!("rc_cloned.apply(42) = {}", rc_cloned.apply(42));
    println!();

    // ====================================================================
    // Part 4: Practical Examples
    // ====================================================================
    println!("=== Practical Examples ===\n");

    // Example 1: String transformation
    println!("--- String Transformation ---");
    let to_upper = BoxTransformer::new(|s: String| s.to_uppercase());
    println!("to_upper.apply('hello') = {}", to_upper.apply("hello".to_string()));
    println!("to_upper.apply('world') = {}", to_upper.apply("world".to_string()));
    println!();

    // Example 2: Type conversion pipeline
    println!("--- Type Conversion Pipeline ---");
    let parse_int = BoxTransformer::new(|s: String| s.parse::<i32>().unwrap_or(0));
    let double_int = BoxTransformer::new(|x: i32| x * 2);
    let to_string = BoxTransformer::new(|x: i32| x.to_string());

    let pipeline = parse_int.and_then(double_int).and_then(to_string);
    println!("pipeline.apply('21') = {}", pipeline.apply("21".to_string()));
    println!();

    // Example 3: Shared transformation logic
    println!("--- Shared Transformation Logic ---");
    let square = ArcTransformer::new(|x: i32| x * x);

    // Can be shared across different parts of the program
    let transformer1 = square.clone();
    let transformer2 = square.clone();

    println!("transformer1.apply(5) = {}", transformer1.apply(5));
    println!("transformer2.apply(7) = {}", transformer2.apply(7));
    println!("square.apply(3) = {}", square.apply(3));
    println!();

    // Example 4: Transformer registry
    println!("--- Transformer Registry ---");
    let mut transformers: HashMap<String, RcTransformer<i32, String>> = HashMap::new();

    transformers.insert(
        "double".to_string(),
        RcTransformer::new(|x: i32| format!("Doubled: {}", x * 2)),
    );
    transformers.insert(
        "square".to_string(),
        RcTransformer::new(|x: i32| format!("Squared: {}", x * x)),
    );

    if let Some(transformer) = transformers.get("double") {
        println!("Transformer 'double': {}", transformer.apply(7));
    }
    if let Some(transformer) = transformers.get("square") {
        println!("Transformer 'square': {}", transformer.apply(7));
    }
    println!();

    // ====================================================================
    // Part 5: Trait Usage
    // ====================================================================
    println!("=== Trait Usage ===\n");

    fn apply_transformer<F: Transformer<i32, String>>(f: &F, x: i32) -> String {
        f.apply(x)
    }

    let to_string = BoxTransformer::new(|x: i32| format!("Value: {}", x));
    println!("Via trait: {}", apply_transformer(&to_string, 42));

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

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

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

Creates a new named 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) -> R + 'static,

Creates a new named 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 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 transformer.

Parameters

• name - The name to set for this transformer

pub fn clear_name(&mut self)

Clears the name of this transformer.

pub fn identity() -> BoxTransformer<T, T>

Creates an identity transformer.

Creates a transformer that returns the input value unchanged. Useful for default values or placeholder implementations.

Returns

Returns a new transformer instance that returns the input unchanged.

Examples found in repository

examples/transformers/transformer_demo.rs (line 32)

fn main() {
    println!("=== Transformer Demo - Type Transformation (consumes T) ===\n");

    // ====================================================================
    // Part 1: BoxTransformer - Single ownership, reusable
    // ====================================================================
    println!("--- BoxTransformer ---");
    let double = BoxTransformer::new(|x: i32| x * 2);
    println!("double.apply(21) = {}", double.apply(21));
    println!("double.apply(42) = {}", double.apply(42));

    // Identity and constant
    let identity = BoxTransformer::<i32, i32>::identity();
    println!("identity.apply(42) = {}", identity.apply(42));

    let constant = BoxTransformer::constant("hello");
    println!("constant.apply(123) = {}", constant.apply(123));
    println!();

    // ====================================================================
    // Part 2: ArcTransformer - Thread-safe, cloneable
    // ====================================================================
    println!("--- ArcTransformer ---");
    let arc_double = ArcTransformer::new(|x: i32| x * 2);
    let arc_cloned = arc_double.clone();

    println!("arc_double.apply(21) = {}", arc_double.apply(21));
    println!("arc_cloned.apply(42) = {}", arc_cloned.apply(42));

    // Multi-threaded usage
    let for_thread = arc_double.clone();
    let handle = thread::spawn(move || for_thread.apply(100));
    println!("In main thread: arc_double.apply(50) = {}", arc_double.apply(50));
    println!(
        "In child thread: result = {}",
        handle.join().expect("thread should not panic")
    );
    println!();

    // ====================================================================
    // Part 3: RcTransformer - Single-threaded, cloneable
    // ====================================================================
    println!("--- RcTransformer ---");
    let rc_double = RcTransformer::new(|x: i32| x * 2);
    let rc_cloned = rc_double.clone();

    println!("rc_double.apply(21) = {}", rc_double.apply(21));
    println!("rc_cloned.apply(42) = {}", rc_cloned.apply(42));
    println!();

    // ====================================================================
    // Part 4: Practical Examples
    // ====================================================================
    println!("=== Practical Examples ===\n");

    // Example 1: String transformation
    println!("--- String Transformation ---");
    let to_upper = BoxTransformer::new(|s: String| s.to_uppercase());
    println!("to_upper.apply('hello') = {}", to_upper.apply("hello".to_string()));
    println!("to_upper.apply('world') = {}", to_upper.apply("world".to_string()));
    println!();

    // Example 2: Type conversion pipeline
    println!("--- Type Conversion Pipeline ---");
    let parse_int = BoxTransformer::new(|s: String| s.parse::<i32>().unwrap_or(0));
    let double_int = BoxTransformer::new(|x: i32| x * 2);
    let to_string = BoxTransformer::new(|x: i32| x.to_string());

    let pipeline = parse_int.and_then(double_int).and_then(to_string);
    println!("pipeline.apply('21') = {}", pipeline.apply("21".to_string()));
    println!();

    // Example 3: Shared transformation logic
    println!("--- Shared Transformation Logic ---");
    let square = ArcTransformer::new(|x: i32| x * x);

    // Can be shared across different parts of the program
    let transformer1 = square.clone();
    let transformer2 = square.clone();

    println!("transformer1.apply(5) = {}", transformer1.apply(5));
    println!("transformer2.apply(7) = {}", transformer2.apply(7));
    println!("square.apply(3) = {}", square.apply(3));
    println!();

    // Example 4: Transformer registry
    println!("--- Transformer Registry ---");
    let mut transformers: HashMap<String, RcTransformer<i32, String>> = HashMap::new();

    transformers.insert(
        "double".to_string(),
        RcTransformer::new(|x: i32| format!("Doubled: {}", x * 2)),
    );
    transformers.insert(
        "square".to_string(),
        RcTransformer::new(|x: i32| format!("Squared: {}", x * x)),
    );

    if let Some(transformer) = transformers.get("double") {
        println!("Transformer 'double': {}", transformer.apply(7));
    }
    if let Some(transformer) = transformers.get("square") {
        println!("Transformer 'square': {}", transformer.apply(7));
    }
    println!();

    // ====================================================================
    // Part 5: Trait Usage
    // ====================================================================
    println!("=== Trait Usage ===\n");

    fn apply_transformer<F: Transformer<i32, String>>(f: &F, x: i32) -> String {
        f.apply(x)
    }

    let to_string = BoxTransformer::new(|x: i32| format!("Value: {}", x));
    println!("Via trait: {}", apply_transformer(&to_string, 42));

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

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

where T: 'static, R: 'static, P: Predicate<T> + 'static,

Creates a conditional transformer that executes based on predicate result.

Parameters

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

Returns

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

Examples

use std::sync::Arc;
use std::sync::atomic::{AtomicI32, Ordering};
use qubit_function::transformers::*;

let transformer = BoxTransformer::new({
    |value: i32| value * 2
});

let conditional = transformer.when(|value: &i32| *value > 0).or_else(|value: i32| value);
assert_eq!(conditional.apply(5), 10);  // transformed
assert_eq!(conditional.apply(-1), -1); // identity (unchanged)

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

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

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

Parameters

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

Returns

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

Examples

use qubit_function::transformers::*;

let transformer1 = BoxTransformer::new({
    |value: i32| value + 1
});

let transformer2 = BoxTransformer::new({
    |value: i32| value * 2
});

let chained = transformer1.and_then(transformer2);
assert_eq!(chained.apply(5), 12); // (5 + 1) * 2 = 12

Examples found in repository

examples/transformers/fn_transformer_ops_demo.rs (line 36)

fn main() {
    println!("=== FnTransformerOps Example ===\n");

    // 1. Basic and_then composition
    println!("1. Basic and_then composition:");
    let double = |x: i32| x * 2;
    let to_string = |x: i32| x.to_string();
    let composed = double.and_then(to_string);
    println!("   double.and_then(to_string).apply(21) = {}", composed.apply(21));
    println!();

    // 2. Chained and_then composition
    println!("2. Chained and_then composition:");
    let add_one = |x: i32| x + 1;
    let double = |x: i32| x * 2;
    let to_string = |x: i32| x.to_string();
    let chained = add_one.and_then(double).and_then(to_string);
    println!(
        "   add_one.and_then(double).and_then(to_string).apply(5) = {}",
        chained.apply(5)
    ); // (5 + 1) * 2 = 12
    println!();

    // 3. compose reverse composition
    println!("3. compose reverse composition:");
    let double = |x: i32| x * 2;
    let add_one = |x: i32| x + 1;
    let composed = double.compose(add_one);
    println!("   double.compose(add_one).apply(5) = {}", composed.apply(5)); // (5 + 1) * 2 = 12
    println!();

    // 4. Conditional transformation when
    println!("4. Conditional transformation when:");
    let double = |x: i32| x * 2;
    let conditional = double.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
    println!("   double.when(x > 0).or_else(negate):");
    println!("     transform(5) = {}", conditional.apply(5)); // 10
    println!("     transform(-5) = {}", conditional.apply(-5)); // 5
    println!();

    // 5. Complex composition
    println!("5. Complex composition:");
    let add_one = |x: i32| x + 1;
    let double = |x: i32| x * 2;
    let triple = |x: i32| x * 3;
    let to_string = |x: i32| x.to_string();

    let complex = add_one
        .and_then(double.when(|x: &i32| *x > 5).or_else(triple))
        .and_then(to_string);

    println!("   add_one.and_then(double.when(x > 5).or_else(triple)).and_then(to_string):");
    println!("     transform(1) = {}", complex.apply(1)); // (1 + 1) = 2 <= 5, so 2 * 3 = 6
    println!("     transform(5) = {}", complex.apply(5)); // (5 + 1) = 6 > 5, so 6 * 2 = 12
    println!("     transform(10) = {}", complex.apply(10)); // (10 + 1) = 11 > 5, so 11 * 2 = 22
    println!();

    // 6. Type conversion
    println!("6. Type conversion:");
    let to_string = |x: i32| x.to_string();
    let get_length = |s: String| s.len();
    let length_transformer = to_string.and_then(get_length);
    println!(
        "   to_string.and_then(get_length).apply(12345) = {}",
        length_transformer.apply(12345)
    ); // 5
    println!();

    // 7. Closures that capture environment
    println!("7. Closures that capture environment:");
    let multiplier = 3;
    let multiply = move |x: i32| x * multiplier;
    let add_ten = |x: i32| x + 10;
    let with_capture = multiply.and_then(add_ten);
    println!("   multiply(3).and_then(add_ten).apply(5) = {}", with_capture.apply(5)); // 5 * 3 + 10 = 25
    println!();

    // 8. Function pointers
    println!("8. Function pointers:");
    fn double_fn(x: i32) -> i32 {
        x * 2
    }
    fn add_one_fn(x: i32) -> i32 {
        x + 1
    }
    let fn_composed = double_fn.and_then(add_one_fn);
    println!("   double_fn.and_then(add_one_fn).apply(5) = {}", fn_composed.apply(5)); // 5 * 2 + 1 = 11
    println!();

    // 9. Multi-conditional transformation
    println!("9. Multi-conditional transformation:");
    let abs = |x: i32| x.abs();
    let double = |x: i32| x * 2;
    let transformer = abs.when(|x: &i32| *x < 0).or_else(double);
    println!("   abs.when(x < 0).or_else(double):");
    println!("     transform(-5) = {}", transformer.apply(-5)); // abs(-5) = 5
    println!("     transform(5) = {}", transformer.apply(5)); // 5 * 2 = 10
    println!("     transform(0) = {}", transformer.apply(0)); // 0 * 2 = 0
    println!();

    println!("=== Example completed ===");
}

examples/transformers/transformer_demo.rs (line 88)

fn main() {
    println!("=== Transformer Demo - Type Transformation (consumes T) ===\n");

    // ====================================================================
    // Part 1: BoxTransformer - Single ownership, reusable
    // ====================================================================
    println!("--- BoxTransformer ---");
    let double = BoxTransformer::new(|x: i32| x * 2);
    println!("double.apply(21) = {}", double.apply(21));
    println!("double.apply(42) = {}", double.apply(42));

    // Identity and constant
    let identity = BoxTransformer::<i32, i32>::identity();
    println!("identity.apply(42) = {}", identity.apply(42));

    let constant = BoxTransformer::constant("hello");
    println!("constant.apply(123) = {}", constant.apply(123));
    println!();

    // ====================================================================
    // Part 2: ArcTransformer - Thread-safe, cloneable
    // ====================================================================
    println!("--- ArcTransformer ---");
    let arc_double = ArcTransformer::new(|x: i32| x * 2);
    let arc_cloned = arc_double.clone();

    println!("arc_double.apply(21) = {}", arc_double.apply(21));
    println!("arc_cloned.apply(42) = {}", arc_cloned.apply(42));

    // Multi-threaded usage
    let for_thread = arc_double.clone();
    let handle = thread::spawn(move || for_thread.apply(100));
    println!("In main thread: arc_double.apply(50) = {}", arc_double.apply(50));
    println!(
        "In child thread: result = {}",
        handle.join().expect("thread should not panic")
    );
    println!();

    // ====================================================================
    // Part 3: RcTransformer - Single-threaded, cloneable
    // ====================================================================
    println!("--- RcTransformer ---");
    let rc_double = RcTransformer::new(|x: i32| x * 2);
    let rc_cloned = rc_double.clone();

    println!("rc_double.apply(21) = {}", rc_double.apply(21));
    println!("rc_cloned.apply(42) = {}", rc_cloned.apply(42));
    println!();

    // ====================================================================
    // Part 4: Practical Examples
    // ====================================================================
    println!("=== Practical Examples ===\n");

    // Example 1: String transformation
    println!("--- String Transformation ---");
    let to_upper = BoxTransformer::new(|s: String| s.to_uppercase());
    println!("to_upper.apply('hello') = {}", to_upper.apply("hello".to_string()));
    println!("to_upper.apply('world') = {}", to_upper.apply("world".to_string()));
    println!();

    // Example 2: Type conversion pipeline
    println!("--- Type Conversion Pipeline ---");
    let parse_int = BoxTransformer::new(|s: String| s.parse::<i32>().unwrap_or(0));
    let double_int = BoxTransformer::new(|x: i32| x * 2);
    let to_string = BoxTransformer::new(|x: i32| x.to_string());

    let pipeline = parse_int.and_then(double_int).and_then(to_string);
    println!("pipeline.apply('21') = {}", pipeline.apply("21".to_string()));
    println!();

    // Example 3: Shared transformation logic
    println!("--- Shared Transformation Logic ---");
    let square = ArcTransformer::new(|x: i32| x * x);

    // Can be shared across different parts of the program
    let transformer1 = square.clone();
    let transformer2 = square.clone();

    println!("transformer1.apply(5) = {}", transformer1.apply(5));
    println!("transformer2.apply(7) = {}", transformer2.apply(7));
    println!("square.apply(3) = {}", square.apply(3));
    println!();

    // Example 4: Transformer registry
    println!("--- Transformer Registry ---");
    let mut transformers: HashMap<String, RcTransformer<i32, String>> = HashMap::new();

    transformers.insert(
        "double".to_string(),
        RcTransformer::new(|x: i32| format!("Doubled: {}", x * 2)),
    );
    transformers.insert(
        "square".to_string(),
        RcTransformer::new(|x: i32| format!("Squared: {}", x * x)),
    );

    if let Some(transformer) = transformers.get("double") {
        println!("Transformer 'double': {}", transformer.apply(7));
    }
    if let Some(transformer) = transformers.get("square") {
        println!("Transformer 'square': {}", transformer.apply(7));
    }
    println!();

    // ====================================================================
    // Part 5: Trait Usage
    // ====================================================================
    println!("=== Trait Usage ===\n");

    fn apply_transformer<F: Transformer<i32, String>>(f: &F, x: i32) -> String {
        f.apply(x)
    }

    let to_string = BoxTransformer::new(|x: i32| format!("Value: {}", x));
    println!("Via trait: {}", apply_transformer(&to_string, 42));

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

impl<T, R> BoxTransformer<T, R>

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

where R: Clone + 'static,

Creates a constant transformer

Examples

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

Examples found in repository

examples/transformers/transformer_demo.rs (line 35)

fn main() {
    println!("=== Transformer Demo - Type Transformation (consumes T) ===\n");

    // ====================================================================
    // Part 1: BoxTransformer - Single ownership, reusable
    // ====================================================================
    println!("--- BoxTransformer ---");
    let double = BoxTransformer::new(|x: i32| x * 2);
    println!("double.apply(21) = {}", double.apply(21));
    println!("double.apply(42) = {}", double.apply(42));

    // Identity and constant
    let identity = BoxTransformer::<i32, i32>::identity();
    println!("identity.apply(42) = {}", identity.apply(42));

    let constant = BoxTransformer::constant("hello");
    println!("constant.apply(123) = {}", constant.apply(123));
    println!();

    // ====================================================================
    // Part 2: ArcTransformer - Thread-safe, cloneable
    // ====================================================================
    println!("--- ArcTransformer ---");
    let arc_double = ArcTransformer::new(|x: i32| x * 2);
    let arc_cloned = arc_double.clone();

    println!("arc_double.apply(21) = {}", arc_double.apply(21));
    println!("arc_cloned.apply(42) = {}", arc_cloned.apply(42));

    // Multi-threaded usage
    let for_thread = arc_double.clone();
    let handle = thread::spawn(move || for_thread.apply(100));
    println!("In main thread: arc_double.apply(50) = {}", arc_double.apply(50));
    println!(
        "In child thread: result = {}",
        handle.join().expect("thread should not panic")
    );
    println!();

    // ====================================================================
    // Part 3: RcTransformer - Single-threaded, cloneable
    // ====================================================================
    println!("--- RcTransformer ---");
    let rc_double = RcTransformer::new(|x: i32| x * 2);
    let rc_cloned = rc_double.clone();

    println!("rc_double.apply(21) = {}", rc_double.apply(21));
    println!("rc_cloned.apply(42) = {}", rc_cloned.apply(42));
    println!();

    // ====================================================================
    // Part 4: Practical Examples
    // ====================================================================
    println!("=== Practical Examples ===\n");

    // Example 1: String transformation
    println!("--- String Transformation ---");
    let to_upper = BoxTransformer::new(|s: String| s.to_uppercase());
    println!("to_upper.apply('hello') = {}", to_upper.apply("hello".to_string()));
    println!("to_upper.apply('world') = {}", to_upper.apply("world".to_string()));
    println!();

    // Example 2: Type conversion pipeline
    println!("--- Type Conversion Pipeline ---");
    let parse_int = BoxTransformer::new(|s: String| s.parse::<i32>().unwrap_or(0));
    let double_int = BoxTransformer::new(|x: i32| x * 2);
    let to_string = BoxTransformer::new(|x: i32| x.to_string());

    let pipeline = parse_int.and_then(double_int).and_then(to_string);
    println!("pipeline.apply('21') = {}", pipeline.apply("21".to_string()));
    println!();

    // Example 3: Shared transformation logic
    println!("--- Shared Transformation Logic ---");
    let square = ArcTransformer::new(|x: i32| x * x);

    // Can be shared across different parts of the program
    let transformer1 = square.clone();
    let transformer2 = square.clone();

    println!("transformer1.apply(5) = {}", transformer1.apply(5));
    println!("transformer2.apply(7) = {}", transformer2.apply(7));
    println!("square.apply(3) = {}", square.apply(3));
    println!();

    // Example 4: Transformer registry
    println!("--- Transformer Registry ---");
    let mut transformers: HashMap<String, RcTransformer<i32, String>> = HashMap::new();

    transformers.insert(
        "double".to_string(),
        RcTransformer::new(|x: i32| format!("Doubled: {}", x * 2)),
    );
    transformers.insert(
        "square".to_string(),
        RcTransformer::new(|x: i32| format!("Squared: {}", x * x)),
    );

    if let Some(transformer) = transformers.get("double") {
        println!("Transformer 'double': {}", transformer.apply(7));
    }
    if let Some(transformer) = transformers.get("square") {
        println!("Transformer 'square': {}", transformer.apply(7));
    }
    println!();

    // ====================================================================
    // Part 5: Trait Usage
    // ====================================================================
    println!("=== Trait Usage ===\n");

    fn apply_transformer<F: Transformer<i32, String>>(f: &F, x: i32) -> String {
        f.apply(x)
    }

    let to_string = BoxTransformer::new(|x: i32| format!("Value: {}", x));
    println!("Via trait: {}", apply_transformer(&to_string, 42));

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

Trait Implementations

impl<T, R> Debug for BoxTransformer<T, R>

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

Formats the value using the given formatter.

impl<T, R> Display for BoxTransformer<T, R>

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

Formats the value using the given formatter.

impl<T, R> Transformer<T, R> for BoxTransformer<T, R>

fn apply(&self, input: T) -> R

Applies the transformation to the input value to produce an output value

fn into_box(self) -> BoxTransformer<T, R>

Converts to BoxTransformer

fn into_rc(self) -> RcTransformer<T, R>

where Self: 'static,

Converts to RcTransformer

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

Converts transformer to a closure

fn into_once(self) -> BoxTransformerOnce<T, R>

where Self: 'static,

Converts to BoxTransformerOnce.

fn into_arc(self) -> ArcTransformer<T, R>

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

Converts to ArcTransformer