Trait TransformerOnce 

pub trait TransformerOnce<T, R> {
    // Required method
    fn apply_once(self, input: T) -> R;

    // Provided methods
    fn into_box_once(self) -> BoxTransformerOnce<T, R>
       where Self: Sized + 'static,
             T: 'static,
             R: 'static { ... }
    fn into_fn_once(self) -> impl FnOnce(T) -> R
       where Self: Sized + 'static,
             T: 'static,
             R: 'static { ... }
    fn to_box_once(&self) -> BoxTransformerOnce<T, R>
       where Self: Clone + 'static,
             T: 'static,
             R: 'static { ... }
    fn to_fn_once(&self) -> impl FnOnce(T) -> R
       where Self: Clone + 'static,
             T: 'static,
             R: 'static { ... }
}

TransformerOnce trait - consuming transformation that takes ownership

Defines the behavior of a consuming transformer: converting a value of type T to a value of type R by taking ownership of both self and the input. This trait is analogous to FnOnce(T) -> R.

Type Parameters

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

Author

Hu Haixing

Required Methods

fn apply_once(self, input: T) -> R

Transforms the input value, consuming both self and input

Parameters

• input - The input value (consumed)

Returns

The transformed output value

Provided Methods

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

where Self: Sized + 'static, T: 'static, R: 'static,

Converts to BoxTransformerOnce

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

Returns

Returns BoxTransformerOnce<T, R>

Examples

use prism3_function::TransformerOnce;

let double = |x: i32| x * 2;
let boxed = double.into_box_once();
assert_eq!(boxed.apply_once(21), 42);

Examples found in repository

examples/transformer_once_blanket_impl_demo.rs (line 35)

fn test_transformer_once() {
    // Test function pointer
    fn parse(s: String) -> i32 {
        s.parse().unwrap_or(0)
    }
    assert_eq!(parse.apply_once("42".to_string()), 42);
    println!("✓ Function pointer test passed: parse.apply_once(\"42\") = 42");

    // Test closure that consumes ownership
    let owned_value = String::from("hello");
    let consume = |s: String| format!("{} world", s);
    assert_eq!(consume.apply_once(owned_value), "hello world");
    println!("✓ Closure that consumes ownership test passed");

    // Test conversion to BoxTransformerOnce
    let transform = |s: String| s.to_uppercase();
    let boxed = transform.into_box_once();
    assert_eq!(boxed.apply_once("hello".to_string()), "HELLO");
    println!("✓ into_box_once() test passed");

    // Test into_fn
    let transform2 = |s: String| s.len();
    let func = transform2.into_fn_once();
    assert_eq!(func("hello".to_string()), 5);
    println!("✓ into_fn_once() test passed");
}

examples/transformer_once_demo.rs (line 33)

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_once(21);
    println!("   double.apply_once(21) = {}", result);

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

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

    println!();

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

    // Use after cloning
    let uppercase = RcTransformer::new(|s: String| s.to_uppercase());
    let uppercase_clone = uppercase.clone();
    let result1 = uppercase.apply_once("world".to_string());
    let result2 = uppercase_clone.apply_once("rust".to_string());
    println!("   uppercase.apply_once(\"world\") = {}", result1);
    println!("   uppercase_clone.apply_once(\"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_once("21".to_string());
    println!("   parse_and_double.apply_once(\"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_once(21)
    });

    let result = handle.join().unwrap();
    println!(
        "   Executed in thread: new_double.apply_once(21) = {}",
        result
    );

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

examples/transformer_once_specialized_methods_demo.rs (line 32)

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_once - consumes self
    let boxed_once = arc_double.clone().into_box_once();
    println!(
        "   ArcTransformer::into_box_once(): {}",
        boxed_once.apply_once(21)
    );

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

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

    // Test to_fn_once - borrows self
    let fn_once_borrowed = arc_double.to_fn_once();
    println!("   ArcTransformer::to_fn_once(): {}", 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_once - consumes self
    let boxed_once = rc_triple.clone().into_box_once();
    println!(
        "   RcTransformer::into_box_once(): {}",
        boxed_once.apply_once(14)
    );

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

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

    // Test to_fn_once - borrows self
    let fn_once_borrowed = rc_triple.to_fn_once();
    println!("   RcTransformer::to_fn_once(): {}", 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_once();
    println!(
        "   Specialized into_box_once: {}",
        specialized_box.apply_once(5)
    );

    // Using default implementation (less efficient)
    let default_box = arc_square.clone().into_box_once();
    println!("   Default into_box_once: {}", default_box.apply_once(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_once();
        boxed.apply_once(50)
    });

    let result = handle.join().unwrap();
    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_once();
    let result = boxed_upper.apply_once(test_string.clone());
    println!(
        "   String transformation: '{}' -> '{}'",
        test_string, result
    );

    // Using to_xxx methods (borrowing)
    let fn_upper = arc_uppercase.to_fn_once();
    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_fn_once(self) -> impl FnOnce(T) -> R

where Self: Sized + 'static, T: 'static, R: 'static,

Converts transformer to a closure

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

Returns

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

Examples

use prism3_function::TransformerOnce;

let double = |x: i32| x * 2;
let func = double.into_fn_once();
assert_eq!(func(21), 42);

Examples found in repository

examples/transformer_once_blanket_impl_demo.rs (line 41)

fn test_transformer_once() {
    // Test function pointer
    fn parse(s: String) -> i32 {
        s.parse().unwrap_or(0)
    }
    assert_eq!(parse.apply_once("42".to_string()), 42);
    println!("✓ Function pointer test passed: parse.apply_once(\"42\") = 42");

    // Test closure that consumes ownership
    let owned_value = String::from("hello");
    let consume = |s: String| format!("{} world", s);
    assert_eq!(consume.apply_once(owned_value), "hello world");
    println!("✓ Closure that consumes ownership test passed");

    // Test conversion to BoxTransformerOnce
    let transform = |s: String| s.to_uppercase();
    let boxed = transform.into_box_once();
    assert_eq!(boxed.apply_once("hello".to_string()), "HELLO");
    println!("✓ into_box_once() test passed");

    // Test into_fn
    let transform2 = |s: String| s.len();
    let func = transform2.into_fn_once();
    assert_eq!(func("hello".to_string()), 5);
    println!("✓ into_fn_once() test passed");
}

examples/transformer_once_demo.rs (line 39)

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_once(21);
    println!("   double.apply_once(21) = {}", result);

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

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

    println!();

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

    // Use after cloning
    let uppercase = RcTransformer::new(|s: String| s.to_uppercase());
    let uppercase_clone = uppercase.clone();
    let result1 = uppercase.apply_once("world".to_string());
    let result2 = uppercase_clone.apply_once("rust".to_string());
    println!("   uppercase.apply_once(\"world\") = {}", result1);
    println!("   uppercase_clone.apply_once(\"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_once("21".to_string());
    println!("   parse_and_double.apply_once(\"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_once(21)
    });

    let result = handle.join().unwrap();
    println!(
        "   Executed in thread: new_double.apply_once(21) = {}",
        result
    );

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

examples/transformer_once_specialized_methods_demo.rs (line 39)

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_once - consumes self
    let boxed_once = arc_double.clone().into_box_once();
    println!(
        "   ArcTransformer::into_box_once(): {}",
        boxed_once.apply_once(21)
    );

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

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

    // Test to_fn_once - borrows self
    let fn_once_borrowed = arc_double.to_fn_once();
    println!("   ArcTransformer::to_fn_once(): {}", 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_once - consumes self
    let boxed_once = rc_triple.clone().into_box_once();
    println!(
        "   RcTransformer::into_box_once(): {}",
        boxed_once.apply_once(14)
    );

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

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

    // Test to_fn_once - borrows self
    let fn_once_borrowed = rc_triple.to_fn_once();
    println!("   RcTransformer::to_fn_once(): {}", 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_once();
    println!(
        "   Specialized into_box_once: {}",
        specialized_box.apply_once(5)
    );

    // Using default implementation (less efficient)
    let default_box = arc_square.clone().into_box_once();
    println!("   Default into_box_once: {}", default_box.apply_once(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_once();
        boxed.apply_once(50)
    });

    let result = handle.join().unwrap();
    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_once();
    let result = boxed_upper.apply_once(test_string.clone());
    println!(
        "   String transformation: '{}' -> '{}'",
        test_string, result
    );

    // Using to_xxx methods (borrowing)
    let fn_upper = arc_uppercase.to_fn_once();
    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_box_once(&self) -> BoxTransformerOnce<T, R>

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

Converts to BoxTransformerOnce without consuming self

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

Default Implementation

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

Returns

Returns BoxTransformerOnce<T, R>

Examples

use prism3_function::TransformerOnce;

let double = |x: i32| x * 2;
let boxed = double.to_box_once();
assert_eq!(boxed.apply_once(21), 42);

Examples found in repository

examples/transformer_once_specialized_methods_demo.rs (line 43)

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_once - consumes self
    let boxed_once = arc_double.clone().into_box_once();
    println!(
        "   ArcTransformer::into_box_once(): {}",
        boxed_once.apply_once(21)
    );

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

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

    // Test to_fn_once - borrows self
    let fn_once_borrowed = arc_double.to_fn_once();
    println!("   ArcTransformer::to_fn_once(): {}", 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_once - consumes self
    let boxed_once = rc_triple.clone().into_box_once();
    println!(
        "   RcTransformer::into_box_once(): {}",
        boxed_once.apply_once(14)
    );

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

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

    // Test to_fn_once - borrows self
    let fn_once_borrowed = rc_triple.to_fn_once();
    println!("   RcTransformer::to_fn_once(): {}", 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_once();
    println!(
        "   Specialized into_box_once: {}",
        specialized_box.apply_once(5)
    );

    // Using default implementation (less efficient)
    let default_box = arc_square.clone().into_box_once();
    println!("   Default into_box_once: {}", default_box.apply_once(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_once();
        boxed.apply_once(50)
    });

    let result = handle.join().unwrap();
    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_once();
    let result = boxed_upper.apply_once(test_string.clone());
    println!(
        "   String transformation: '{}' -> '{}'",
        test_string, result
    );

    // Using to_xxx methods (borrowing)
    let fn_upper = arc_uppercase.to_fn_once();
    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_fn_once(&self) -> impl FnOnce(T) -> R

where Self: Clone + 'static, T: 'static, R: '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 FnOnce(T) -> R

Examples

use prism3_function::TransformerOnce;

let double = |x: i32| x * 2;
let func = double.to_fn_once();
assert_eq!(func(21), 42);

Examples found in repository

examples/transformer_once_specialized_methods_demo.rs (line 50)

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_once - consumes self
    let boxed_once = arc_double.clone().into_box_once();
    println!(
        "   ArcTransformer::into_box_once(): {}",
        boxed_once.apply_once(21)
    );

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

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

    // Test to_fn_once - borrows self
    let fn_once_borrowed = arc_double.to_fn_once();
    println!("   ArcTransformer::to_fn_once(): {}", 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_once - consumes self
    let boxed_once = rc_triple.clone().into_box_once();
    println!(
        "   RcTransformer::into_box_once(): {}",
        boxed_once.apply_once(14)
    );

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

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

    // Test to_fn_once - borrows self
    let fn_once_borrowed = rc_triple.to_fn_once();
    println!("   RcTransformer::to_fn_once(): {}", 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_once();
    println!(
        "   Specialized into_box_once: {}",
        specialized_box.apply_once(5)
    );

    // Using default implementation (less efficient)
    let default_box = arc_square.clone().into_box_once();
    println!("   Default into_box_once: {}", default_box.apply_once(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_once();
        boxed.apply_once(50)
    });

    let result = handle.join().unwrap();
    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_once();
    let result = boxed_upper.apply_once(test_string.clone());
    println!(
        "   String transformation: '{}' -> '{}'",
        test_string, result
    );

    // Using to_xxx methods (borrowing)
    let fn_upper = arc_uppercase.to_fn_once();
    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! ===");
}

Implementors

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

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

Implement TransformerOnce<T, R> for any type that implements FnOnce(T) -> R

This allows once-callable closures and function pointers to be used directly with our TransformerOnce trait without wrapping.

Examples

use prism3_function::TransformerOnce;

fn parse(s: String) -> i32 {
    s.parse().unwrap_or(0)
}

assert_eq!(parse.apply_once("42".to_string()), 42);

let owned_value = String::from("hello");
let consume = |s: String| {
    format!("{} world", s)
};
assert_eq!(consume.apply_once(owned_value), "hello world");

Author

Hu Haixing

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

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

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

where T: 'static, R: 'static,

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

where T: 'static, R: 'static,

impl<T, R> TransformerOnce<T, R> for BoxTransformerOnce<T, R>