Trait FnMapperOps 

pub trait FnMapperOps<T, R>:
    FnMut(T) -> R
    + Sized
    + 'static {
    // Provided methods
    fn and_then<S, F>(self, after: F) -> BoxMapper<T, S>
       where S: 'static,
             F: Mapper<R, S> + 'static,
             T: 'static,
             R: 'static { ... }
    fn compose<S, F>(self, before: F) -> BoxMapper<S, R>
       where S: 'static,
             F: Mapper<S, T> + 'static,
             T: 'static,
             R: 'static { ... }
    fn when<P>(self, predicate: P) -> BoxConditionalMapper<T, R>
       where P: Predicate<T> + 'static,
             T: 'static,
             R: 'static { ... }
}

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

Provides composition methods (and_then, compose, when) for closures without requiring explicit wrapping in BoxMapper, RcMapper, or ArcMapper.

This trait is automatically implemented for all closures that implement FnMut(T) -> R.

Design Rationale

While closures automatically implement Mapper<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 BoxMapper for maximum flexibility.

Examples

Chain composition with and_then

use prism3_function::{Mapper, FnMapperOps};

let mut counter1 = 0;
let mapper1 = move |x: i32| {
    counter1 += 1;
    x + counter1
};

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

let mut composed = mapper1.and_then(mapper2);
assert_eq!(composed.apply(10), 11);  // (10 + 1) * 1

Reverse composition with compose

use prism3_function::{Mapper, FnMapperOps};

let mut counter = 0;
let mapper = move |x: i32| {
    counter += 1;
    x * counter
};

let mut composed = mapper.compose(|x: i32| x + 1);
assert_eq!(composed.apply(10), 11); // (10 + 1) * 1

Conditional mapping with when

use prism3_function::{Mapper, FnMapperOps};

let mut mapper = (|x: i32| x * 2)
    .when(|x: &i32| *x > 0)
    .or_else(|x: i32| -x);

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

Author

Haixing Hu

Provided Methods

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

where S: 'static, F: Mapper<R, S> + 'static, T: 'static, R: 'static,

Chain composition - applies self first, then after

Creates a new mapper that applies this mapper first, then applies the after mapper to the result. Consumes self and returns a BoxMapper.

Type Parameters

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

Parameters

• after - The mapper to apply after self. Can be:
  • A closure: |x: R| -> S
  • A BoxMapper<R, S>
  • An RcMapper<R, S>
  • An ArcMapper<R, S>
  • Any type implementing Mapper<R, S>

Returns

A new BoxMapper<T, S> representing the composition

Examples

use prism3_function::{Mapper, FnMapperOps, BoxMapper};

let mut counter1 = 0;
let mapper1 = move |x: i32| {
    counter1 += 1;
    x + counter1
};

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

let mut composed = mapper1.and_then(mapper2);
assert_eq!(composed.apply(10), 11);

Examples found in repository

examples/mapper_demo.rs (line 104)

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

    // 1. Basic BoxMapper with state
    println!("1. BoxMapper with stateful counter:");
    let mut counter = 0;
    let mut mapper = BoxMapper::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 = BoxMapper::new(move |x: i32| {
        counter1 += 1;
        x + counter1
    });

    let mut counter2 = 0;
    let mapper2 = BoxMapper::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 = BoxMapper::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. RcMapper for cloneable mappers
    println!("\n4. RcMapper (cloneable, single-threaded):");
    let mut counter = 0;
    let mapper = RcMapper::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. ArcMapper for thread-safe mappers
    println!("\n5. ArcMapper (thread-safe):");
    let mut counter = 0;
    let mapper = ArcMapper::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 FnMapperOps extension trait
    println!("\n6. Using FnMapperOps 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 = BoxMapper::new(move |x: i32| {
        step1_count += 1;
        format!("Step1[{}]: {}", step1_count, x)
    });

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

    let mut step3_count = 0;
    let step3 = BoxMapper::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. MapperOnce implementation - consuming mappers
    println!("\n7. MapperOnce implementation - consuming Mappers:");

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

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

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

    // 8. Converting to BoxMapperOnce
    println!("\n8. Converting Mappers to BoxMapperOnce:");

    let mut counter = 0;
    let mapper = BoxMapper::new(move |x: i32| {
        counter += 1;
        x * counter
    });
    let once_mapper = mapper.into_box_once();
    println!("  BoxMapper->BoxMapperOnce: {}", once_mapper.apply_once(5)); // 5 * 1 = 5

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

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

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

where S: 'static, F: Mapper<S, T> + 'static, T: 'static, R: 'static,

Reverse composition - applies before first, then self

Creates a new mapper that applies the before mapper first, then applies this mapper to the result. Consumes self and returns a BoxMapper.

Type Parameters

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

Parameters

• before - The mapper to apply before self. Can be:
  • A closure: |x: S| -> T
  • A BoxMapper<S, T>
  • An RcMapper<S, T>
  • An ArcMapper<S, T>
  • Any type implementing Mapper<S, T>

Returns

A new BoxMapper<S, R> representing the composition

Examples

use prism3_function::{Mapper, FnMapperOps, BoxMapper};

let mut counter = 0;
let mapper = move |x: i32| {
    counter += 1;
    x * counter
};

let before = BoxMapper::new(|x: i32| x + 1);

let mut composed = mapper.compose(before);
assert_eq!(composed.apply(10), 11); // (10 + 1) * 1

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

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

Creates a conditional mapper

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

Parameters

• predicate - The condition to check. 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 BoxConditionalMapper<T, R>

Examples

use prism3_function::{Mapper, FnMapperOps};

let mut mapper = (|x: i32| x * 2)
    .when(|x: &i32| *x > 0)
    .or_else(|x: i32| -x);

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

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> FnMapperOps<T, R> for F

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

Blanket implementation of FnMapperOps for all closures

Automatically implements FnMapperOps<T, R> for any type that implements FnMut(T) -> R.

Author

Haixing Hu