Struct RcConditionalTransformer 

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

RcConditionalTransformer struct

A single-threaded conditional transformer that only executes when a predicate is satisfied. Uses RcTransformer and RcPredicate for shared ownership within a single thread.

This type is typically created by calling RcTransformer::when() and is designed to work with the or_else() method to create if-then-else logic.

Features

• Shared Ownership: Cloneable via Rc, multiple owners allowed
• Single-Threaded: Not thread-safe, cannot be sent across threads
• Conditional Execution: Only transforms when predicate returns true
• No Lock Overhead: More efficient than ArcConditionalTransformer

Examples

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);

Author

Haixing Hu

Implementations

impl<T, R> RcConditionalTransformer<T, R>

where T: 'static, R: 'static,

pub fn or_else<F>(self, else_transformer: F) -> RcTransformer<T, R>

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

Adds an else branch (single-threaded shared version)

Executes the original transformer when the condition is satisfied, otherwise executes else_transformer.

Parameters

• else_transformer - The transformer for the else branch, can be:
  • Closure: |x: T| -> R
  • RcTransformer<T, R>, BoxTransformer<T, R>
  • Any type implementing Transformer<T, R>

Returns

Returns the composed RcTransformer<T, R>

Examples

Using a closure (recommended)

use prism3_function::{Transformer, RcTransformer};

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

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

Trait Implementations

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

fn clone(&self) -> Self

Clones the conditional transformer

Creates a new instance that shares the underlying transformer and predicate with the original instance.

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

Performs copy-assignment from source.