Trait Transformer 

pub trait Transformer<T, R> {
    // Required method
    fn apply(&self, input: T) -> R;

    // Provided methods
    fn into_box(self) -> BoxTransformer<T, R>
       where Self: Sized + 'static { ... }
    fn into_rc(self) -> RcTransformer<T, R>
       where Self: Sized + 'static { ... }
    fn into_arc(self) -> ArcTransformer<T, R>
       where Self: Sized + Send + Sync + 'static { ... }
    fn into_fn(self) -> impl Fn(T) -> R
       where Self: Sized + 'static { ... }
    fn into_once(self) -> BoxTransformerOnce<T, R>
       where Self: Sized + 'static { ... }
    fn to_box(&self) -> BoxTransformer<T, R>
       where Self: Clone + 'static { ... }
    fn to_rc(&self) -> RcTransformer<T, R>
       where Self: Clone + 'static { ... }
    fn to_arc(&self) -> ArcTransformer<T, R>
       where Self: Clone + Send + Sync + 'static { ... }
    fn to_fn(&self) -> impl Fn(T) -> R
       where Self: Clone + 'static { ... }
    fn to_once(&self) -> BoxTransformerOnce<T, R>
       where Self: Clone + 'static { ... }
}

Transformer trait - transforms values from type T to type R

Defines the behavior of a transformation: converting a value of type T to a value of type R by consuming the input. This is analogous to Fn(T) -> R in Rust’s standard library.

Type Parameters

• T - The type of the input value (consumed)
• R - The type of the output value

Required Methods

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

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

Parameters

• input - The input value to transform (consumed)

Returns

The transformed output value

Provided Methods

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

where Self: Sized + 'static,

Converts to BoxTransformer

⚠️ Consumes self: The original transformer becomes unavailable after calling this method.

Default Implementation

The default implementation wraps self in a Box and creates a BoxTransformer. Types can override this method to provide more efficient conversions.

Returns

Returns BoxTransformer<T, R>

Examples found in repository

examples/transformers/transformer_blanket_impl_demo.rs (line 35)

fn test_transformer() {
    // Test function pointer
    fn double(x: i32) -> i32 {
        x * 2
    }
    assert_eq!(double.apply(21), 42);
    println!("✓ Function pointer test passed: double.apply(21) = 42");

    // Test closure
    let triple = |x: i32| x * 3;
    assert_eq!(triple.apply(14), 42);
    println!("✓ Closure test passed: triple.apply(14) = 42");

    // Test conversion to BoxTransformer
    let quad = |x: i32| x * 4;
    let boxed = Transformer::into_box(quad);
    assert_eq!(boxed.apply(10), 40);
    println!("✓ into_box() test passed");

    // Test conversion to RcTransformer
    let times_five = |x: i32| x * 5;
    let rc = Transformer::into_rc(times_five);
    assert_eq!(rc.apply(8), 40);
    println!("✓ into_rc() test passed");

    // Test conversion to ArcTransformer
    let times_six = |x: i32| x * 6;
    let arc = Transformer::into_arc(times_six);
    assert_eq!(arc.apply(7), 42);
    println!("✓ into_arc() test passed");
}

examples/transformers/transformer_once_demo.rs (line 36)

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_once_specialized_methods_demo.rs (line 34)

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

    // ============================================================================
    // ArcTransformer TransformerOnce specialized methods
    // ============================================================================

    println!("1. ArcTransformer TransformerOnce specialized methods:");

    let arc_double = ArcTransformer::new(|x: i32| x * 2);

    // Test into_box - consumes self
    let boxed_once = arc_double.clone().into_box();
    println!("   ArcTransformer::into_box(): {}", boxed_once.apply(21));

    // Test into_fn - consumes self
    let fn_once = arc_double.clone().into_fn();
    println!("   ArcTransformer::into_fn(): {}", fn_once(21));

    // Test to_box - borrows self
    let boxed_once_borrowed = arc_double.to_box();
    println!("   ArcTransformer::to_box(): {}", boxed_once_borrowed.apply(21));

    // Test to_fn - borrows self
    let fn_once_borrowed = arc_double.to_fn();
    println!("   ArcTransformer::to_fn(): {}", fn_once_borrowed(21));

    // Original transformer still usable after to_xxx methods
    println!("   Original ArcTransformer still works: {}", arc_double.apply(21));

    println!();

    // ============================================================================
    // RcTransformer TransformerOnce specialized methods
    // ============================================================================

    println!("2. RcTransformer TransformerOnce specialized methods:");

    let rc_triple = RcTransformer::new(|x: i32| x * 3);

    // Test into_box - consumes self
    let boxed_once = rc_triple.clone().into_box();
    println!("   RcTransformer::into_box(): {}", boxed_once.apply(14));

    // Test into_fn - consumes self
    let fn_once = rc_triple.clone().into_fn();
    println!("   RcTransformer::into_fn(): {}", fn_once(14));

    // Test to_box - borrows self
    let boxed_once_borrowed = rc_triple.to_box();
    println!("   RcTransformer::to_box(): {}", boxed_once_borrowed.apply(14));

    // Test to_fn - borrows self
    let fn_once_borrowed = rc_triple.to_fn();
    println!("   RcTransformer::to_fn(): {}", fn_once_borrowed(14));

    // Original transformer still usable after to_xxx methods
    println!("   Original RcTransformer still works: {}", rc_triple.apply(14));

    println!();

    // ============================================================================
    // Comparison with default implementations
    // ============================================================================

    println!("3. Performance comparison (specialized vs default):");

    let arc_square = ArcTransformer::new(|x: i32| x * x);

    // Using specialized method (more efficient)
    let specialized_box = arc_square.clone().into_box();
    println!("   Specialized into_box: {}", specialized_box.apply(5));

    // Using default implementation (less efficient)
    let default_box = arc_square.clone().into_box();
    println!("   Default into_box: {}", default_box.apply(5));

    println!();

    // ============================================================================
    // Thread safety demonstration for ArcTransformer
    // ============================================================================

    println!("4. Thread safety with ArcTransformer:");

    let arc_shared = ArcTransformer::new(|x: i32| x + 100);

    // Clone for thread safety
    let arc_clone = arc_shared.clone();

    // Use in different thread context (simulated)
    let handle = std::thread::spawn(move || {
        let boxed = arc_clone.into_box();
        boxed.apply(50)
    });

    let result = handle.join().expect("thread should not panic");
    println!("   Thread-safe ArcTransformer result: {}", result);

    // Original still usable
    println!("   Original ArcTransformer still works: {}", arc_shared.apply(50));

    println!();

    // ============================================================================
    // String transformation example
    // ============================================================================

    println!("5. String transformation with specialized methods:");

    let arc_uppercase = ArcTransformer::new(|s: String| s.to_uppercase());

    // Test with string input
    let test_string = "hello world".to_string();

    // Using specialized methods
    let boxed_upper = arc_uppercase.clone().into_box();
    let result = boxed_upper.apply(test_string.clone());
    println!("   String transformation: '{}' -> '{}'", test_string, result);

    // Using to_xxx methods (borrowing)
    let fn_upper = arc_uppercase.to_fn();
    let result2 = fn_upper(test_string.clone());
    println!(
        "   String transformation (borrowed): '{}' -> '{}'",
        test_string, result2
    );

    // Original still usable
    println!(
        "   Original ArcTransformer still works: '{}'",
        arc_uppercase.apply(test_string)
    );

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

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

where Self: Sized + 'static,

Converts to RcTransformer

⚠️ Consumes self: The original transformer becomes unavailable after calling this method.

Default Implementation

The default implementation wraps self in an Rc and creates an RcTransformer. Types can override this method to provide more efficient conversions.

Returns

Returns RcTransformer<T, R>

Examples found in repository

examples/transformers/transformer_blanket_impl_demo.rs (line 41)

fn test_transformer() {
    // Test function pointer
    fn double(x: i32) -> i32 {
        x * 2
    }
    assert_eq!(double.apply(21), 42);
    println!("✓ Function pointer test passed: double.apply(21) = 42");

    // Test closure
    let triple = |x: i32| x * 3;
    assert_eq!(triple.apply(14), 42);
    println!("✓ Closure test passed: triple.apply(14) = 42");

    // Test conversion to BoxTransformer
    let quad = |x: i32| x * 4;
    let boxed = Transformer::into_box(quad);
    assert_eq!(boxed.apply(10), 40);
    println!("✓ into_box() test passed");

    // Test conversion to RcTransformer
    let times_five = |x: i32| x * 5;
    let rc = Transformer::into_rc(times_five);
    assert_eq!(rc.apply(8), 40);
    println!("✓ into_rc() test passed");

    // Test conversion to ArcTransformer
    let times_six = |x: i32| x * 6;
    let arc = Transformer::into_arc(times_six);
    assert_eq!(arc.apply(7), 42);
    println!("✓ into_arc() test passed");
}

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

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

Converts to ArcTransformer

⚠️ Consumes self: The original transformer becomes unavailable after calling this method.

Default Implementation

The default implementation wraps self in an Arc and creates an ArcTransformer. Types can override this method to provide more efficient conversions.

Returns

Returns ArcTransformer<T, R>

Examples found in repository

examples/transformers/transformer_blanket_impl_demo.rs (line 47)

fn test_transformer() {
    // Test function pointer
    fn double(x: i32) -> i32 {
        x * 2
    }
    assert_eq!(double.apply(21), 42);
    println!("✓ Function pointer test passed: double.apply(21) = 42");

    // Test closure
    let triple = |x: i32| x * 3;
    assert_eq!(triple.apply(14), 42);
    println!("✓ Closure test passed: triple.apply(14) = 42");

    // Test conversion to BoxTransformer
    let quad = |x: i32| x * 4;
    let boxed = Transformer::into_box(quad);
    assert_eq!(boxed.apply(10), 40);
    println!("✓ into_box() test passed");

    // Test conversion to RcTransformer
    let times_five = |x: i32| x * 5;
    let rc = Transformer::into_rc(times_five);
    assert_eq!(rc.apply(8), 40);
    println!("✓ into_rc() test passed");

    // Test conversion to ArcTransformer
    let times_six = |x: i32| x * 6;
    let arc = Transformer::into_arc(times_six);
    assert_eq!(arc.apply(7), 42);
    println!("✓ into_arc() test passed");
}

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

where Self: Sized + 'static,

Converts transformer to a closure

⚠️ Consumes self: The original transformer becomes unavailable after calling this method.

Default Implementation

The default implementation creates a closure that captures self and calls its transform method. Types can override this method to provide more efficient conversions.

Returns

Returns a closure that implements Fn(T) -> R

Examples found in repository

examples/transformers/transformer_once_demo.rs (line 42)

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_once_specialized_methods_demo.rs (line 38)

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

    // ============================================================================
    // ArcTransformer TransformerOnce specialized methods
    // ============================================================================

    println!("1. ArcTransformer TransformerOnce specialized methods:");

    let arc_double = ArcTransformer::new(|x: i32| x * 2);

    // Test into_box - consumes self
    let boxed_once = arc_double.clone().into_box();
    println!("   ArcTransformer::into_box(): {}", boxed_once.apply(21));

    // Test into_fn - consumes self
    let fn_once = arc_double.clone().into_fn();
    println!("   ArcTransformer::into_fn(): {}", fn_once(21));

    // Test to_box - borrows self
    let boxed_once_borrowed = arc_double.to_box();
    println!("   ArcTransformer::to_box(): {}", boxed_once_borrowed.apply(21));

    // Test to_fn - borrows self
    let fn_once_borrowed = arc_double.to_fn();
    println!("   ArcTransformer::to_fn(): {}", fn_once_borrowed(21));

    // Original transformer still usable after to_xxx methods
    println!("   Original ArcTransformer still works: {}", arc_double.apply(21));

    println!();

    // ============================================================================
    // RcTransformer TransformerOnce specialized methods
    // ============================================================================

    println!("2. RcTransformer TransformerOnce specialized methods:");

    let rc_triple = RcTransformer::new(|x: i32| x * 3);

    // Test into_box - consumes self
    let boxed_once = rc_triple.clone().into_box();
    println!("   RcTransformer::into_box(): {}", boxed_once.apply(14));

    // Test into_fn - consumes self
    let fn_once = rc_triple.clone().into_fn();
    println!("   RcTransformer::into_fn(): {}", fn_once(14));

    // Test to_box - borrows self
    let boxed_once_borrowed = rc_triple.to_box();
    println!("   RcTransformer::to_box(): {}", boxed_once_borrowed.apply(14));

    // Test to_fn - borrows self
    let fn_once_borrowed = rc_triple.to_fn();
    println!("   RcTransformer::to_fn(): {}", fn_once_borrowed(14));

    // Original transformer still usable after to_xxx methods
    println!("   Original RcTransformer still works: {}", rc_triple.apply(14));

    println!();

    // ============================================================================
    // Comparison with default implementations
    // ============================================================================

    println!("3. Performance comparison (specialized vs default):");

    let arc_square = ArcTransformer::new(|x: i32| x * x);

    // Using specialized method (more efficient)
    let specialized_box = arc_square.clone().into_box();
    println!("   Specialized into_box: {}", specialized_box.apply(5));

    // Using default implementation (less efficient)
    let default_box = arc_square.clone().into_box();
    println!("   Default into_box: {}", default_box.apply(5));

    println!();

    // ============================================================================
    // Thread safety demonstration for ArcTransformer
    // ============================================================================

    println!("4. Thread safety with ArcTransformer:");

    let arc_shared = ArcTransformer::new(|x: i32| x + 100);

    // Clone for thread safety
    let arc_clone = arc_shared.clone();

    // Use in different thread context (simulated)
    let handle = std::thread::spawn(move || {
        let boxed = arc_clone.into_box();
        boxed.apply(50)
    });

    let result = handle.join().expect("thread should not panic");
    println!("   Thread-safe ArcTransformer result: {}", result);

    // Original still usable
    println!("   Original ArcTransformer still works: {}", arc_shared.apply(50));

    println!();

    // ============================================================================
    // String transformation example
    // ============================================================================

    println!("5. String transformation with specialized methods:");

    let arc_uppercase = ArcTransformer::new(|s: String| s.to_uppercase());

    // Test with string input
    let test_string = "hello world".to_string();

    // Using specialized methods
    let boxed_upper = arc_uppercase.clone().into_box();
    let result = boxed_upper.apply(test_string.clone());
    println!("   String transformation: '{}' -> '{}'", test_string, result);

    // Using to_xxx methods (borrowing)
    let fn_upper = arc_uppercase.to_fn();
    let result2 = fn_upper(test_string.clone());
    println!(
        "   String transformation (borrowed): '{}' -> '{}'",
        test_string, result2
    );

    // Original still usable
    println!(
        "   Original ArcTransformer still works: '{}'",
        arc_uppercase.apply(test_string)
    );

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

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

where Self: Sized + 'static,

Converts to BoxTransformerOnce.

This method has a default implementation that wraps the transformer in a BoxTransformerOnce. Custom implementations can override this method for optimization purposes.

Returns

A new BoxTransformerOnce<T, R> instance

Examples

use qubit_function::{Transformer, TransformerOnce};

let closure = |x: i32| x * 2;
let once = closure.into_once();
assert_eq!(once.apply(5), 10);

fn to_box(&self) -> BoxTransformer<T, R>

where Self: Clone + 'static,

Converts to BoxTransformer without consuming self

📌 Borrows &self: The original transformer remains usable after calling this method.

Default Implementation

The default implementation creates a new BoxTransformer that captures a reference-counted clone. Types implementing Clone can override this method to provide more efficient conversions.

Returns

Returns BoxTransformer<T, R>

Examples

use qubit_function::{ArcTransformer, Transformer};

let double = ArcTransformer::new(|x: i32| x * 2);
let boxed = double.to_box();

// Original transformer still usable
assert_eq!(double.apply(21), 42);
assert_eq!(boxed.apply(21), 42);

Examples found in repository

examples/transformers/transformer_once_specialized_methods_demo.rs (line 42)

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

    // ============================================================================
    // ArcTransformer TransformerOnce specialized methods
    // ============================================================================

    println!("1. ArcTransformer TransformerOnce specialized methods:");

    let arc_double = ArcTransformer::new(|x: i32| x * 2);

    // Test into_box - consumes self
    let boxed_once = arc_double.clone().into_box();
    println!("   ArcTransformer::into_box(): {}", boxed_once.apply(21));

    // Test into_fn - consumes self
    let fn_once = arc_double.clone().into_fn();
    println!("   ArcTransformer::into_fn(): {}", fn_once(21));

    // Test to_box - borrows self
    let boxed_once_borrowed = arc_double.to_box();
    println!("   ArcTransformer::to_box(): {}", boxed_once_borrowed.apply(21));

    // Test to_fn - borrows self
    let fn_once_borrowed = arc_double.to_fn();
    println!("   ArcTransformer::to_fn(): {}", fn_once_borrowed(21));

    // Original transformer still usable after to_xxx methods
    println!("   Original ArcTransformer still works: {}", arc_double.apply(21));

    println!();

    // ============================================================================
    // RcTransformer TransformerOnce specialized methods
    // ============================================================================

    println!("2. RcTransformer TransformerOnce specialized methods:");

    let rc_triple = RcTransformer::new(|x: i32| x * 3);

    // Test into_box - consumes self
    let boxed_once = rc_triple.clone().into_box();
    println!("   RcTransformer::into_box(): {}", boxed_once.apply(14));

    // Test into_fn - consumes self
    let fn_once = rc_triple.clone().into_fn();
    println!("   RcTransformer::into_fn(): {}", fn_once(14));

    // Test to_box - borrows self
    let boxed_once_borrowed = rc_triple.to_box();
    println!("   RcTransformer::to_box(): {}", boxed_once_borrowed.apply(14));

    // Test to_fn - borrows self
    let fn_once_borrowed = rc_triple.to_fn();
    println!("   RcTransformer::to_fn(): {}", fn_once_borrowed(14));

    // Original transformer still usable after to_xxx methods
    println!("   Original RcTransformer still works: {}", rc_triple.apply(14));

    println!();

    // ============================================================================
    // Comparison with default implementations
    // ============================================================================

    println!("3. Performance comparison (specialized vs default):");

    let arc_square = ArcTransformer::new(|x: i32| x * x);

    // Using specialized method (more efficient)
    let specialized_box = arc_square.clone().into_box();
    println!("   Specialized into_box: {}", specialized_box.apply(5));

    // Using default implementation (less efficient)
    let default_box = arc_square.clone().into_box();
    println!("   Default into_box: {}", default_box.apply(5));

    println!();

    // ============================================================================
    // Thread safety demonstration for ArcTransformer
    // ============================================================================

    println!("4. Thread safety with ArcTransformer:");

    let arc_shared = ArcTransformer::new(|x: i32| x + 100);

    // Clone for thread safety
    let arc_clone = arc_shared.clone();

    // Use in different thread context (simulated)
    let handle = std::thread::spawn(move || {
        let boxed = arc_clone.into_box();
        boxed.apply(50)
    });

    let result = handle.join().expect("thread should not panic");
    println!("   Thread-safe ArcTransformer result: {}", result);

    // Original still usable
    println!("   Original ArcTransformer still works: {}", arc_shared.apply(50));

    println!();

    // ============================================================================
    // String transformation example
    // ============================================================================

    println!("5. String transformation with specialized methods:");

    let arc_uppercase = ArcTransformer::new(|s: String| s.to_uppercase());

    // Test with string input
    let test_string = "hello world".to_string();

    // Using specialized methods
    let boxed_upper = arc_uppercase.clone().into_box();
    let result = boxed_upper.apply(test_string.clone());
    println!("   String transformation: '{}' -> '{}'", test_string, result);

    // Using to_xxx methods (borrowing)
    let fn_upper = arc_uppercase.to_fn();
    let result2 = fn_upper(test_string.clone());
    println!(
        "   String transformation (borrowed): '{}' -> '{}'",
        test_string, result2
    );

    // Original still usable
    println!(
        "   Original ArcTransformer still works: '{}'",
        arc_uppercase.apply(test_string)
    );

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

fn to_rc(&self) -> RcTransformer<T, R>

where Self: Clone + 'static,

Converts to RcTransformer without consuming self

📌 Borrows &self: The original transformer remains usable after calling this method.

Default Implementation

The default implementation creates a new RcTransformer that captures a reference-counted clone. Types implementing Clone can override this method to provide more efficient conversions.

Returns

Returns RcTransformer<T, R>

Examples

use qubit_function::{ArcTransformer, Transformer};

let double = ArcTransformer::new(|x: i32| x * 2);
let rc = double.to_rc();

// Original transformer still usable
assert_eq!(double.apply(21), 42);
assert_eq!(rc.apply(21), 42);

fn to_arc(&self) -> ArcTransformer<T, R>

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

Converts to ArcTransformer without consuming self

📌 Borrows &self: The original transformer remains usable after calling this method.

Default Implementation

The default implementation creates a new ArcTransformer that captures a reference-counted clone. Types implementing Clone can override this method to provide more efficient conversions.

Returns

Returns ArcTransformer<T, R>

Examples

use qubit_function::{ArcTransformer, Transformer};

let double = ArcTransformer::new(|x: i32| x * 2);
let arc = double.to_arc();

// Original transformer still usable
assert_eq!(double.apply(21), 42);
assert_eq!(arc.apply(21), 42);

fn to_fn(&self) -> impl Fn(T) -> R

where Self: Clone + 'static,

Converts transformer to a closure without consuming self

📌 Borrows &self: The original transformer remains usable after calling this method.

Default Implementation

The default implementation creates a closure that captures a clone of self and calls its transform method. Types can override this method to provide more efficient conversions.

Returns

Returns a closure that implements Fn(T) -> R

Examples

use qubit_function::{ArcTransformer, Transformer};

let double = ArcTransformer::new(|x: i32| x * 2);
let closure = double.to_fn();

// Original transformer still usable
assert_eq!(double.apply(21), 42);
assert_eq!(closure(21), 42);

Examples found in repository

examples/transformers/transformer_once_specialized_methods_demo.rs (line 46)

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

    // ============================================================================
    // ArcTransformer TransformerOnce specialized methods
    // ============================================================================

    println!("1. ArcTransformer TransformerOnce specialized methods:");

    let arc_double = ArcTransformer::new(|x: i32| x * 2);

    // Test into_box - consumes self
    let boxed_once = arc_double.clone().into_box();
    println!("   ArcTransformer::into_box(): {}", boxed_once.apply(21));

    // Test into_fn - consumes self
    let fn_once = arc_double.clone().into_fn();
    println!("   ArcTransformer::into_fn(): {}", fn_once(21));

    // Test to_box - borrows self
    let boxed_once_borrowed = arc_double.to_box();
    println!("   ArcTransformer::to_box(): {}", boxed_once_borrowed.apply(21));

    // Test to_fn - borrows self
    let fn_once_borrowed = arc_double.to_fn();
    println!("   ArcTransformer::to_fn(): {}", fn_once_borrowed(21));

    // Original transformer still usable after to_xxx methods
    println!("   Original ArcTransformer still works: {}", arc_double.apply(21));

    println!();

    // ============================================================================
    // RcTransformer TransformerOnce specialized methods
    // ============================================================================

    println!("2. RcTransformer TransformerOnce specialized methods:");

    let rc_triple = RcTransformer::new(|x: i32| x * 3);

    // Test into_box - consumes self
    let boxed_once = rc_triple.clone().into_box();
    println!("   RcTransformer::into_box(): {}", boxed_once.apply(14));

    // Test into_fn - consumes self
    let fn_once = rc_triple.clone().into_fn();
    println!("   RcTransformer::into_fn(): {}", fn_once(14));

    // Test to_box - borrows self
    let boxed_once_borrowed = rc_triple.to_box();
    println!("   RcTransformer::to_box(): {}", boxed_once_borrowed.apply(14));

    // Test to_fn - borrows self
    let fn_once_borrowed = rc_triple.to_fn();
    println!("   RcTransformer::to_fn(): {}", fn_once_borrowed(14));

    // Original transformer still usable after to_xxx methods
    println!("   Original RcTransformer still works: {}", rc_triple.apply(14));

    println!();

    // ============================================================================
    // Comparison with default implementations
    // ============================================================================

    println!("3. Performance comparison (specialized vs default):");

    let arc_square = ArcTransformer::new(|x: i32| x * x);

    // Using specialized method (more efficient)
    let specialized_box = arc_square.clone().into_box();
    println!("   Specialized into_box: {}", specialized_box.apply(5));

    // Using default implementation (less efficient)
    let default_box = arc_square.clone().into_box();
    println!("   Default into_box: {}", default_box.apply(5));

    println!();

    // ============================================================================
    // Thread safety demonstration for ArcTransformer
    // ============================================================================

    println!("4. Thread safety with ArcTransformer:");

    let arc_shared = ArcTransformer::new(|x: i32| x + 100);

    // Clone for thread safety
    let arc_clone = arc_shared.clone();

    // Use in different thread context (simulated)
    let handle = std::thread::spawn(move || {
        let boxed = arc_clone.into_box();
        boxed.apply(50)
    });

    let result = handle.join().expect("thread should not panic");
    println!("   Thread-safe ArcTransformer result: {}", result);

    // Original still usable
    println!("   Original ArcTransformer still works: {}", arc_shared.apply(50));

    println!();

    // ============================================================================
    // String transformation example
    // ============================================================================

    println!("5. String transformation with specialized methods:");

    let arc_uppercase = ArcTransformer::new(|s: String| s.to_uppercase());

    // Test with string input
    let test_string = "hello world".to_string();

    // Using specialized methods
    let boxed_upper = arc_uppercase.clone().into_box();
    let result = boxed_upper.apply(test_string.clone());
    println!("   String transformation: '{}' -> '{}'", test_string, result);

    // Using to_xxx methods (borrowing)
    let fn_upper = arc_uppercase.to_fn();
    let result2 = fn_upper(test_string.clone());
    println!(
        "   String transformation (borrowed): '{}' -> '{}'",
        test_string, result2
    );

    // Original still usable
    println!(
        "   Original ArcTransformer still works: '{}'",
        arc_uppercase.apply(test_string)
    );

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

fn to_once(&self) -> BoxTransformerOnce<T, R>

where Self: Clone + 'static,

Converts to BoxTransformerOnce without consuming self

⚠️ Requires Clone: This method requires Self to implement Clone. Clones the current transformer and converts the clone to a one-time transformer.

Returns

Returns a BoxTransformerOnce<T, R>

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

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

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

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

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

where F: Fn(T) -> R,