Struct RcTransformer 

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

RcTransformer - single-threaded transformer wrapper

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

Features

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

Author

Hu Haixing

Implementations

impl<T, R> RcTransformer<T, R>

where T: 'static, R: 'static,

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

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

Creates a new RcTransformer

Parameters

• f - The closure or function to wrap

Examples

use prism3_function::{RcTransformer, Transformer};

let double = RcTransformer::new(|x: i32| x * 2);
assert_eq!(double.apply(21), 42);

Examples found in repository

examples/transformer_once_demo.rs (line 47)

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_demo.rs (line 57)

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().unwrap());
    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 ===");
}

examples/transformer_once_specialized_methods_demo.rs (line 67)

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

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

Creates an identity transformer

Examples

use prism3_function::{RcTransformer, Transformer};

let identity = RcTransformer::<i32, i32>::identity();
assert_eq!(identity.apply(42), 42);

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

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

Chain composition - applies self first, then after

Creates a new transformer that applies this transformer first, then applies the after transformer to the result. Uses &self, so original transformer remains usable.

Type Parameters

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

Parameters

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

Returns

A new RcTransformer representing the composition

Examples

Direct value passing (ownership transfer)

use prism3_function::{RcTransformer, Transformer};

let double = RcTransformer::new(|x: i32| x * 2);
let to_string = RcTransformer::new(|x: i32| x.to_string());

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

// Original double transformer still usable (uses &self)
assert_eq!(double.apply(21), 42);
assert_eq!(composed.apply(21), "42");
// to_string.apply(5); // Would not compile - moved

Preserving original with clone

use prism3_function::{RcTransformer, Transformer};

let double = RcTransformer::new(|x: i32| x * 2);
let to_string = RcTransformer::new(|x: i32| x.to_string());

// Clone to preserve original
let composed = double.and_then(to_string.clone());
assert_eq!(composed.apply(21), "42");

// Both originals still usable
assert_eq!(double.apply(21), 42);
assert_eq!(to_string.apply(5), "5");

pub fn compose<S, F>(&self, before: F) -> RcTransformer<S, R>

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

Reverse composition - applies before first, then self

Creates a new transformer that applies the before transformer first, then applies this transformer to the result. Uses &self, so original transformer remains usable.

Type Parameters

• S - The input type of the before transformer
• F - The type of the before transformer (must implement Transformer<S, T>)

Parameters

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

Returns

A new RcTransformer representing the composition

Examples

Direct value passing (ownership transfer)

use prism3_function::{RcTransformer, Transformer};

let double = RcTransformer::new(|x: i32| x * 2);
let add_one = RcTransformer::new(|x: i32| x + 1);

// add_one is moved here
let composed = double.compose(add_one);
assert_eq!(composed.apply(5), 12); // (5 + 1) * 2
// add_one.apply(3); // Would not compile - moved

Preserving original with clone

use prism3_function::{RcTransformer, Transformer};

let double = RcTransformer::new(|x: i32| x * 2);
let add_one = RcTransformer::new(|x: i32| x + 1);

// Clone to preserve original
let composed = double.compose(add_one.clone());
assert_eq!(composed.apply(5), 12); // (5 + 1) * 2

// Both originals still usable
assert_eq!(double.apply(10), 20);
assert_eq!(add_one.apply(3), 4);

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

where P: Predicate<T> + 'static,

Creates a conditional transformer (single-threaded shared version)

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

Parameters

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

Returns

Returns RcConditionalTransformer<T, R>

Examples

Basic usage with or_else

use prism3_function::{Transformer, RcTransformer};

let double = RcTransformer::new(|x: i32| x * 2);
let identity = RcTransformer::<i32, i32>::identity();
let conditional = double.when(|x: &i32| *x > 0).or_else(identity);

let conditional_clone = conditional.clone();

assert_eq!(conditional.apply(5), 10);
assert_eq!(conditional_clone.apply(-5), -5);

Preserving predicate with clone

use prism3_function::{Transformer, RcTransformer, RcPredicate};

let double = RcTransformer::new(|x: i32| x * 2);
let is_positive = RcPredicate::new(|x: &i32| *x > 0);

// Clone to preserve original predicate
let conditional = double.when(is_positive.clone())
    .or_else(RcTransformer::identity());

assert_eq!(conditional.apply(5), 10);

// Original predicate still usable
assert!(is_positive.test(&3));

impl<T, R> RcTransformer<T, R>

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

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

Creates a constant transformer

Examples

use prism3_function::{RcTransformer, Transformer};

let constant = RcTransformer::constant("hello");
assert_eq!(constant.apply(123), "hello");

Trait Implementations

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, R> Transformer<T, R> for RcTransformer<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>

where T: 'static, R: 'static,

Converts to BoxTransformer

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

where T: 'static, R: 'static,

Converts to RcTransformer

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

where T: 'static, R: 'static,

Converts transformer to a closure

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

where T: 'static, R: 'static,

Converts to BoxTransformer without consuming self

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

where T: 'static, R: 'static,

Converts to RcTransformer without consuming self

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

where T: 'static, R: 'static,

Converts transformer to a closure without consuming self

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

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

Converts to ArcTransformer

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

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

Converts to ArcTransformer without consuming self

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

where T: 'static, R: 'static,

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

Examples

use prism3_function::{RcTransformer, TransformerOnce};

let double = RcTransformer::new(|x: i32| x * 2);
let result = double.apply_once(21);
assert_eq!(result, 42);

Author

Hu Haixing

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

where 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::{RcTransformer, TransformerOnce};

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

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

where 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::{RcTransformer, TransformerOnce};

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

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

where T: 'static, R: 'static,

Converts to BoxTransformerOnce without consuming self

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

Returns

Returns BoxTransformerOnce<T, R>

Examples

use prism3_function::{RcTransformer, TransformerOnce};

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

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

fn to_fn_once(&self) -> impl FnOnce(T) -> R

where T: 'static, R: 'static,

Converts transformer to a closure without consuming self

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

Returns

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

Examples

use prism3_function::{RcTransformer, TransformerOnce};

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

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