Trait FnStatefulTransformerOps 

pub trait FnStatefulTransformerOps<T, R>: FnMut(T) -> R + Sized {
    // Provided methods
    fn and_then<S, F>(self, after: F) -> BoxStatefulTransformer<T, S>
       where Self: 'static,
             S: 'static,
             F: StatefulTransformer<R, S> + 'static,
             T: 'static,
             R: 'static { ... }
    fn compose<S, F>(self, before: F) -> BoxStatefulTransformer<S, R>
       where Self: 'static,
             S: 'static,
             F: StatefulTransformer<S, T> + 'static,
             T: 'static,
             R: 'static { ... }
    fn when<P>(self, predicate: P) -> BoxConditionalStatefulTransformer<T, R>
       where Self: 'static,
             P: Predicate<T> + 'static,
             T: 'static,
             R: 'static { ... }
}

Extension trait for closures implementing the base transformer trait

Provides composition methods (and_then, compose, when) for closures and function pointers without requiring explicit wrapping.

This trait is automatically implemented for all closures and function pointers that implement the base transformer trait.

Design Rationale

While closures automatically implement the base transformer trait through blanket implementation, they don’t have access to instance methods like and_then, compose, and when. This extension trait provides those methods, returning the appropriate Box-based transformer type for maximum flexibility.

Provided Methods

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

where Self: 'static, S: 'static, F: StatefulTransformer<R, S> + 'static, T: 'static, R: '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. Consumes self and returns a Box-based transformer.

Type Parameters

• S - The output type of the after transformer
• F - The type of the after transformer (must implement the transformer trait)

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
  • A function pointer
  • A Box-based transformer
  • An Rc-based transformer
  • An Arc-based transformer
  • Any type implementing the transformer trait

Returns

A new Box-based transformer representing the composition

Examples

Direct value passing (ownership transfer)

use qubit_function::{BoxTransformer, FnTransformerOps, Transformer};

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

// to_string is moved here
let composed = double.and_then(to_string);
assert_eq!(composed.apply(21), "42");
// to_string.apply(5); // Would not compile - moved

Preserving behavior with separate closures

use qubit_function::{BoxTransformer, FnTransformerOps, Transformer};

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

let composed = double.and_then(BoxTransformer::new(|x: i32| x.to_string()));
assert_eq!(composed.apply(21), "42");

assert_eq!(to_string_for_validation(5), "5");

Examples found in repository

examples/transformers/stateful_transformer_demo.rs (line 111)

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

    // 1. Basic BoxStatefulTransformer with state
    println!("1. BoxStatefulTransformer with stateful counter:");
    let mut counter = 0;
    let mut mapper = BoxStatefulTransformer::new(move |x: i32| {
        counter += 1;
        format!("Item #{}: {}", counter, x)
    });

    println!("  {}", mapper.apply(100)); // Item #1: 100
    println!("  {}", mapper.apply(200)); // Item #2: 200
    println!("  {}", mapper.apply(300)); // Item #3: 300

    // 2. Composing mappers with and_then
    println!("\n2. Composing mappers with and_then:");
    let mut counter1 = 0;
    let mapper1 = BoxStatefulTransformer::new(move |x: i32| {
        counter1 += 1;
        x + counter1
    });

    let mut counter2 = 0;
    let mapper2 = BoxStatefulTransformer::new(move |x: i32| {
        counter2 += 1;
        x * counter2
    });

    let mut composed = mapper1.and_then(mapper2);
    println!("  First call:  {}", composed.apply(10)); // (10 + 1) * 1 = 11
    println!("  Second call: {}", composed.apply(10)); // (10 + 2) * 2 = 24
    println!("  Third call:  {}", composed.apply(10)); // (10 + 3) * 3 = 39

    // 3. Conditional mapping with when/or_else
    println!("\n3. Conditional mapping:");
    let mut high_count = 0;
    let mut low_count = 0;

    let mut conditional = BoxStatefulTransformer::new(move |x: i32| {
        high_count += 1;
        format!("High[{}]: {} * 2 = {}", high_count, x, x * 2)
    })
    .when(|x: &i32| *x >= 10)
    .or_else(move |x| {
        low_count += 1;
        format!("Low[{}]: {} + 1 = {}", low_count, x, x + 1)
    });

    println!("  {}", conditional.apply(15)); // High[1]: 15 * 2 = 30
    println!("  {}", conditional.apply(5)); // Low[1]: 5 + 1 = 6
    println!("  {}", conditional.apply(20)); // High[2]: 20 * 2 = 40

    // 4. RcStatefulTransformer for cloneable mappers
    println!("\n4. RcStatefulTransformer (cloneable, single-threaded):");
    let mut counter = 0;
    let mapper = RcStatefulTransformer::new(move |x: i32| {
        counter += 1;
        x + counter
    });

    let mut mapper1 = mapper.clone();
    let mut mapper2 = mapper.clone();

    println!("  mapper1: {}", mapper1.apply(10)); // 11
    println!("  mapper2: {}", mapper2.apply(10)); // 12
    println!("  mapper1: {}", mapper1.apply(10)); // 13

    // 5. ArcStatefulTransformer for thread-safe mappers
    println!("\n5. ArcStatefulTransformer (thread-safe):");
    let mut counter = 0;
    let mapper = ArcStatefulTransformer::new(move |x: i32| {
        counter += 1;
        format!("Result[{}]: {}", counter, x * 2)
    });

    let mut mapper_clone = mapper.clone();
    println!("  Original: {}", mapper_clone.apply(5)); // Result[1]: 10
    println!("  Clone:    {}", mapper_clone.apply(7)); // Result[2]: 14

    // 6. Using FnStatefulTransformerOps extension trait
    println!("\n6. Using FnStatefulTransformerOps extension trait:");
    let mut count = 0;
    let mut mapper = (move |x: i32| {
        count += 1;
        x + count
    })
    .and_then(|x| x * 2);

    println!("  {}", mapper.apply(10)); // (10 + 1) * 2 = 22
    println!("  {}", mapper.apply(10)); // (10 + 2) * 2 = 24

    // 7. Building a complex pipeline
    println!("\n7. Complex processing pipeline:");
    let mut step1_count = 0;
    let step1 = BoxStatefulTransformer::new(move |x: i32| {
        step1_count += 1;
        format!("Step1[{}]: {}", step1_count, x)
    });

    let mut step2_count = 0;
    let step2 = BoxStatefulTransformer::new(move |s: String| {
        step2_count += 1;
        format!("{} -> Step2[{}]", s, step2_count)
    });

    let mut step3_count = 0;
    let step3 = BoxStatefulTransformer::new(move |s: String| {
        step3_count += 1;
        format!("{} -> Step3[{}]", s, step3_count)
    });

    let mut pipeline = step1.and_then(step2).and_then(step3);

    println!("  {}", pipeline.apply(100));
    println!("  {}", pipeline.apply(200));

    // 7. TransformerOnce implementation - consuming transformers
    println!("\n7. TransformerOnce implementation - consuming StatefulTransformers:");

    // BoxStatefulTransformer can be consumed as TransformerOnce
    let mut counter = 0;
    let mut box_mapper = BoxStatefulTransformer::new(move |x: i32| {
        counter += 1;
        x * counter
    });
    println!("  BoxStatefulTransformer consumed once: {}", box_mapper.apply(10)); // 10 * 1 = 10

    // RcStatefulTransformer can be consumed as TransformerOnce
    let mut counter = 0;
    let mut rc_mapper = RcStatefulTransformer::new(move |x: i32| {
        counter += 1;
        x + counter
    });
    let rc_clone = rc_mapper.clone(); // Clone before consuming
    println!("  RcStatefulTransformer consumed once: {}", rc_mapper.apply(10)); // 10 + 1 = 11
    println!("  RcStatefulTransformer clone still works: {}", {
        let mut rc_clone_for_call = rc_clone.clone();
        rc_clone_for_call.apply(10)
    }); // 10 + 2 = 12

    // ArcStatefulTransformer can be consumed as TransformerOnce
    let mut counter = 0;
    let mut arc_mapper = ArcStatefulTransformer::new(move |x: i32| {
        counter += 1;
        x * counter
    });
    let arc_clone = arc_mapper.clone(); // Clone before consuming
    println!("  ArcStatefulTransformer consumed once: {}", arc_mapper.apply(10)); // 10 * 1 = 10
    println!("  ArcStatefulTransformer clone still works: {}", {
        let mut arc_clone_for_call = arc_clone.clone();
        arc_clone_for_call.apply(10)
    }); // 10 * 2 = 20

    // 8. Converting to BoxTransformerOnce
    println!("\n8. Converting StatefulTransformers to BoxTransformerOnce:");

    let mut counter = 0;
    let mapper = BoxStatefulTransformer::new(move |x: i32| {
        counter += 1;
        x * counter
    });
    let mut once_mapper = mapper.into_box();
    println!("  BoxStatefulTransformer->BoxTransformerOnce: {}", once_mapper.apply(5)); // 5 * 1 = 5

    // RcStatefulTransformer can use to_box() to preserve original
    let mut counter = 0;
    let rc_mapper = RcStatefulTransformer::new(move |x: i32| {
        counter += 1;
        x * counter
    });
    let mut once_mapper = rc_mapper.to_box();
    println!("  RcStatefulTransformer->BoxTransformerOnce: {}", once_mapper.apply(5)); // 5 * 1 = 5
    println!("  Original RcStatefulTransformer still works: {}", {
        let mut rc_original_for_call = rc_mapper.clone();
        rc_original_for_call.apply(5)
    }); // 5 * 2 = 10

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

fn compose<S, F>(self, before: F) -> BoxStatefulTransformer<S, R>

where Self: 'static, S: 'static, F: StatefulTransformer<S, T> + 'static, T: 'static, R: '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. Consumes self and returns a Box-based transformer.

Type Parameters

• S - The input type of the before transformer
• F - The type of the before transformer

Parameters

• before - The transformer to apply before self.

Returns

A new Box-based transformer representing the reverse composition.

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

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

Creates a conditional transformer

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

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 the appropriate conditional transformer type

Examples

Basic usage with or_else

use qubit_function::{Transformer, FnTransformerOps};

let double = |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);

Reusing equivalent predicate logic

use qubit_function::{FnTransformerOps, Transformer};

let double = |x: i32| x * 2;
let is_positive_for_validation = |x: &i32| *x > 0;

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

assert_eq!(conditional.apply(5), 10);
assert!(is_positive_for_validation(&3));

Dyn Compatibility

This trait is not dyn compatible.

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

Implementors

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

where F: FnMut(T) -> R,

Blanket implementation for all closures

Automatically implements the extension trait for any type that implements the base transformer trait.