Trait FnTransformerOps 

pub trait FnTransformerOps<T, R>: Fn(T) -> R + Sized {
    // Provided methods
    fn and_then<S, F>(self, after: F) -> BoxTransformer<T, S>
       where Self: 'static,
             S: 'static,
             F: Transformer<R, S> + 'static,
             T: 'static,
             R: 'static { ... }
    fn compose<S, F>(self, before: F) -> BoxTransformer<S, R>
       where Self: 'static,
             S: 'static,
             F: Transformer<S, T> + 'static,
             T: 'static,
             R: 'static { ... }
    fn when<P>(self, predicate: P) -> BoxConditionalTransformer<T, R>
       where Self: 'static,
             P: Predicate<T> + 'static,
             T: 'static,
             R: 'static { ... }
}

Extension trait for closures implementing Fn(T) -> R

Provides composition methods (and_then, compose, when) for closures and function pointers without requiring explicit wrapping in BoxTransformer, RcTransformer, or ArcTransformer.

This trait is automatically implemented for all closures and function pointers that implement Fn(T) -> R.

Design Rationale

While closures automatically implement Transformer<T, R> through blanket implementation, they don’t have access to instance methods like and_then, compose, and when. This extension trait provides those methods, returning BoxTransformer for maximum flexibility.

Examples

Chain composition with and_then

use qubit_function::{Transformer, FnTransformerOps};

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

let composed = double.and_then(to_string);
assert_eq!(composed.apply(21), "42");

Reverse composition with compose

use qubit_function::{Transformer, FnTransformerOps};

let double = |x: i32| x * 2;
let add_one = |x: i32| x + 1;

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

Conditional transformation with when

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

Provided Methods

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

where Self: 'static, S: 'static, F: Transformer<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 BoxTransformer.

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>
  • An ArcTransformer<R, S>
  • Any type implementing Transformer<R, S>

Returns

A new BoxTransformer<T, S> representing the composition

Examples

Direct value passing (ownership transfer)

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

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 original with separate closures

use qubit_function::{Transformer, FnTransformerOps};

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

let composed = double.and_then(to_string);
assert_eq!(composed.apply(21), "42");

// Original still usable
assert_eq!(to_string_for_validation(5), "5");

Examples found in repository

examples/transformers/fn_transformer_ops_demo.rs (line 27)

fn main() {
    println!("=== FnTransformerOps Example ===\n");

    // 1. Basic and_then composition
    println!("1. Basic and_then composition:");
    let double = |x: i32| x * 2;
    let to_string = |x: i32| x.to_string();
    let composed = double.and_then(to_string);
    println!(
        "   double.and_then(to_string).apply(21) = {}",
        composed.apply(21)
    );
    println!();

    // 2. Chained and_then composition
    println!("2. Chained and_then composition:");
    let add_one = |x: i32| x + 1;
    let double = |x: i32| x * 2;
    let to_string = |x: i32| x.to_string();
    let chained = add_one.and_then(double).and_then(to_string);
    println!(
        "   add_one.and_then(double).and_then(to_string).apply(5) = {}",
        chained.apply(5)
    ); // (5 + 1) * 2 = 12
    println!();

    // 3. compose reverse composition
    println!("3. compose reverse composition:");
    let double = |x: i32| x * 2;
    let add_one = |x: i32| x + 1;
    let composed = double.compose(add_one);
    println!(
        "   double.compose(add_one).apply(5) = {}",
        composed.apply(5)
    ); // (5 + 1) * 2 = 12
    println!();

    // 4. Conditional transformation when
    println!("4. Conditional transformation when:");
    let double = |x: i32| x * 2;
    let conditional = double.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
    println!("   double.when(x > 0).or_else(negate):");
    println!("     transform(5) = {}", conditional.apply(5)); // 10
    println!("     transform(-5) = {}", conditional.apply(-5)); // 5
    println!();

    // 5. Complex composition
    println!("5. Complex composition:");
    let add_one = |x: i32| x + 1;
    let double = |x: i32| x * 2;
    let triple = |x: i32| x * 3;
    let to_string = |x: i32| x.to_string();

    let complex = add_one
        .and_then(double.when(|x: &i32| *x > 5).or_else(triple))
        .and_then(to_string);

    println!("   add_one.and_then(double.when(x > 5).or_else(triple)).and_then(to_string):");
    println!("     transform(1) = {}", complex.apply(1)); // (1 + 1) = 2 <= 5, so 2 * 3 = 6
    println!("     transform(5) = {}", complex.apply(5)); // (5 + 1) = 6 > 5, so 6 * 2 = 12
    println!("     transform(10) = {}", complex.apply(10)); // (10 + 1) = 11 > 5, so 11 * 2 = 22
    println!();

    // 6. Type conversion
    println!("6. Type conversion:");
    let to_string = |x: i32| x.to_string();
    let get_length = |s: String| s.len();
    let length_transformer = to_string.and_then(get_length);
    println!(
        "   to_string.and_then(get_length).apply(12345) = {}",
        length_transformer.apply(12345)
    ); // 5
    println!();

    // 7. Closures that capture environment
    println!("7. Closures that capture environment:");
    let multiplier = 3;
    let multiply = move |x: i32| x * multiplier;
    let add_ten = |x: i32| x + 10;
    let with_capture = multiply.and_then(add_ten);
    println!(
        "   multiply(3).and_then(add_ten).apply(5) = {}",
        with_capture.apply(5)
    ); // 5 * 3 + 10 = 25
    println!();

    // 8. Function pointers
    println!("8. Function pointers:");
    fn double_fn(x: i32) -> i32 {
        x * 2
    }
    fn add_one_fn(x: i32) -> i32 {
        x + 1
    }
    let fn_composed = double_fn.and_then(add_one_fn);
    println!(
        "   double_fn.and_then(add_one_fn).apply(5) = {}",
        fn_composed.apply(5)
    ); // 5 * 2 + 1 = 11
    println!();

    // 9. Multi-conditional transformation
    println!("9. Multi-conditional transformation:");
    let abs = |x: i32| x.abs();
    let double = |x: i32| x * 2;
    let transformer = abs.when(|x: &i32| *x < 0).or_else(double);
    println!("   abs.when(x < 0).or_else(double):");
    println!("     transform(-5) = {}", transformer.apply(-5)); // abs(-5) = 5
    println!("     transform(5) = {}", transformer.apply(5)); // 5 * 2 = 10
    println!("     transform(0) = {}", transformer.apply(0)); // 0 * 2 = 0
    println!();

    println!("=== Example completed ===");
}

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

where Self: 'static, S: 'static, F: Transformer<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 BoxTransformer.

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>
  • An ArcTransformer<S, T>
  • Any type implementing Transformer<S, T>

Returns

A new BoxTransformer<S, R> representing the composition

Examples

Direct value passing (ownership transfer)

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

let double = |x: i32| x * 2;
let add_one = BoxTransformer::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 separate closures

use qubit_function::{Transformer, FnTransformerOps};

let double = |x: i32| x * 2;
let add_one = |x: i32| x + 1;
let add_one_for_validation = |x: i32| x + 1;

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

// Original still usable
assert_eq!(add_one_for_validation(3), 4);

Examples found in repository

examples/transformers/fn_transformer_ops_demo.rs (line 50)

fn main() {
    println!("=== FnTransformerOps Example ===\n");

    // 1. Basic and_then composition
    println!("1. Basic and_then composition:");
    let double = |x: i32| x * 2;
    let to_string = |x: i32| x.to_string();
    let composed = double.and_then(to_string);
    println!(
        "   double.and_then(to_string).apply(21) = {}",
        composed.apply(21)
    );
    println!();

    // 2. Chained and_then composition
    println!("2. Chained and_then composition:");
    let add_one = |x: i32| x + 1;
    let double = |x: i32| x * 2;
    let to_string = |x: i32| x.to_string();
    let chained = add_one.and_then(double).and_then(to_string);
    println!(
        "   add_one.and_then(double).and_then(to_string).apply(5) = {}",
        chained.apply(5)
    ); // (5 + 1) * 2 = 12
    println!();

    // 3. compose reverse composition
    println!("3. compose reverse composition:");
    let double = |x: i32| x * 2;
    let add_one = |x: i32| x + 1;
    let composed = double.compose(add_one);
    println!(
        "   double.compose(add_one).apply(5) = {}",
        composed.apply(5)
    ); // (5 + 1) * 2 = 12
    println!();

    // 4. Conditional transformation when
    println!("4. Conditional transformation when:");
    let double = |x: i32| x * 2;
    let conditional = double.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
    println!("   double.when(x > 0).or_else(negate):");
    println!("     transform(5) = {}", conditional.apply(5)); // 10
    println!("     transform(-5) = {}", conditional.apply(-5)); // 5
    println!();

    // 5. Complex composition
    println!("5. Complex composition:");
    let add_one = |x: i32| x + 1;
    let double = |x: i32| x * 2;
    let triple = |x: i32| x * 3;
    let to_string = |x: i32| x.to_string();

    let complex = add_one
        .and_then(double.when(|x: &i32| *x > 5).or_else(triple))
        .and_then(to_string);

    println!("   add_one.and_then(double.when(x > 5).or_else(triple)).and_then(to_string):");
    println!("     transform(1) = {}", complex.apply(1)); // (1 + 1) = 2 <= 5, so 2 * 3 = 6
    println!("     transform(5) = {}", complex.apply(5)); // (5 + 1) = 6 > 5, so 6 * 2 = 12
    println!("     transform(10) = {}", complex.apply(10)); // (10 + 1) = 11 > 5, so 11 * 2 = 22
    println!();

    // 6. Type conversion
    println!("6. Type conversion:");
    let to_string = |x: i32| x.to_string();
    let get_length = |s: String| s.len();
    let length_transformer = to_string.and_then(get_length);
    println!(
        "   to_string.and_then(get_length).apply(12345) = {}",
        length_transformer.apply(12345)
    ); // 5
    println!();

    // 7. Closures that capture environment
    println!("7. Closures that capture environment:");
    let multiplier = 3;
    let multiply = move |x: i32| x * multiplier;
    let add_ten = |x: i32| x + 10;
    let with_capture = multiply.and_then(add_ten);
    println!(
        "   multiply(3).and_then(add_ten).apply(5) = {}",
        with_capture.apply(5)
    ); // 5 * 3 + 10 = 25
    println!();

    // 8. Function pointers
    println!("8. Function pointers:");
    fn double_fn(x: i32) -> i32 {
        x * 2
    }
    fn add_one_fn(x: i32) -> i32 {
        x + 1
    }
    let fn_composed = double_fn.and_then(add_one_fn);
    println!(
        "   double_fn.and_then(add_one_fn).apply(5) = {}",
        fn_composed.apply(5)
    ); // 5 * 2 + 1 = 11
    println!();

    // 9. Multi-conditional transformation
    println!("9. Multi-conditional transformation:");
    let abs = |x: i32| x.abs();
    let double = |x: i32| x * 2;
    let transformer = abs.when(|x: &i32| *x < 0).or_else(double);
    println!("   abs.when(x < 0).or_else(double):");
    println!("     transform(-5) = {}", transformer.apply(-5)); // abs(-5) = 5
    println!("     transform(5) = {}", transformer.apply(5)); // 5 * 2 = 10
    println!("     transform(0) = {}", transformer.apply(0)); // 0 * 2 = 0
    println!();

    println!("=== Example completed ===");
}

fn when<P>(self, predicate: P) -> BoxConditionalTransformer<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 BoxConditionalTransformer<T, R>

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

Preserving original with separate predicates

use qubit_function::{Transformer, FnTransformerOps};

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

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

// Original predicate still usable
assert!(is_positive_for_validation(&3));

Examples found in repository

examples/transformers/fn_transformer_ops_demo.rs (line 60)

fn main() {
    println!("=== FnTransformerOps Example ===\n");

    // 1. Basic and_then composition
    println!("1. Basic and_then composition:");
    let double = |x: i32| x * 2;
    let to_string = |x: i32| x.to_string();
    let composed = double.and_then(to_string);
    println!(
        "   double.and_then(to_string).apply(21) = {}",
        composed.apply(21)
    );
    println!();

    // 2. Chained and_then composition
    println!("2. Chained and_then composition:");
    let add_one = |x: i32| x + 1;
    let double = |x: i32| x * 2;
    let to_string = |x: i32| x.to_string();
    let chained = add_one.and_then(double).and_then(to_string);
    println!(
        "   add_one.and_then(double).and_then(to_string).apply(5) = {}",
        chained.apply(5)
    ); // (5 + 1) * 2 = 12
    println!();

    // 3. compose reverse composition
    println!("3. compose reverse composition:");
    let double = |x: i32| x * 2;
    let add_one = |x: i32| x + 1;
    let composed = double.compose(add_one);
    println!(
        "   double.compose(add_one).apply(5) = {}",
        composed.apply(5)
    ); // (5 + 1) * 2 = 12
    println!();

    // 4. Conditional transformation when
    println!("4. Conditional transformation when:");
    let double = |x: i32| x * 2;
    let conditional = double.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
    println!("   double.when(x > 0).or_else(negate):");
    println!("     transform(5) = {}", conditional.apply(5)); // 10
    println!("     transform(-5) = {}", conditional.apply(-5)); // 5
    println!();

    // 5. Complex composition
    println!("5. Complex composition:");
    let add_one = |x: i32| x + 1;
    let double = |x: i32| x * 2;
    let triple = |x: i32| x * 3;
    let to_string = |x: i32| x.to_string();

    let complex = add_one
        .and_then(double.when(|x: &i32| *x > 5).or_else(triple))
        .and_then(to_string);

    println!("   add_one.and_then(double.when(x > 5).or_else(triple)).and_then(to_string):");
    println!("     transform(1) = {}", complex.apply(1)); // (1 + 1) = 2 <= 5, so 2 * 3 = 6
    println!("     transform(5) = {}", complex.apply(5)); // (5 + 1) = 6 > 5, so 6 * 2 = 12
    println!("     transform(10) = {}", complex.apply(10)); // (10 + 1) = 11 > 5, so 11 * 2 = 22
    println!();

    // 6. Type conversion
    println!("6. Type conversion:");
    let to_string = |x: i32| x.to_string();
    let get_length = |s: String| s.len();
    let length_transformer = to_string.and_then(get_length);
    println!(
        "   to_string.and_then(get_length).apply(12345) = {}",
        length_transformer.apply(12345)
    ); // 5
    println!();

    // 7. Closures that capture environment
    println!("7. Closures that capture environment:");
    let multiplier = 3;
    let multiply = move |x: i32| x * multiplier;
    let add_ten = |x: i32| x + 10;
    let with_capture = multiply.and_then(add_ten);
    println!(
        "   multiply(3).and_then(add_ten).apply(5) = {}",
        with_capture.apply(5)
    ); // 5 * 3 + 10 = 25
    println!();

    // 8. Function pointers
    println!("8. Function pointers:");
    fn double_fn(x: i32) -> i32 {
        x * 2
    }
    fn add_one_fn(x: i32) -> i32 {
        x + 1
    }
    let fn_composed = double_fn.and_then(add_one_fn);
    println!(
        "   double_fn.and_then(add_one_fn).apply(5) = {}",
        fn_composed.apply(5)
    ); // 5 * 2 + 1 = 11
    println!();

    // 9. Multi-conditional transformation
    println!("9. Multi-conditional transformation:");
    let abs = |x: i32| x.abs();
    let double = |x: i32| x * 2;
    let transformer = abs.when(|x: &i32| *x < 0).or_else(double);
    println!("   abs.when(x < 0).or_else(double):");
    println!("     transform(-5) = {}", transformer.apply(-5)); // abs(-5) = 5
    println!("     transform(5) = {}", transformer.apply(5)); // 5 * 2 = 10
    println!("     transform(0) = {}", transformer.apply(0)); // 0 * 2 = 0
    println!();

    println!("=== Example completed ===");
}

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

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

where F: Fn(T) -> R,

Blanket implementation of FnTransformerOps for all closures

Automatically implements FnTransformerOps<T, R> for any type that implements Fn(T) -> R.