Struct BoxMapper 

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

BoxMapper - mapper wrapper based on Box<dyn FnMut>

A mapper wrapper that provides single ownership with reusable stateful transformation. The mapper consumes the input and can be called multiple times while maintaining internal state.

Features

• Based on: Box<dyn FnMut(T) -> R>
• Ownership: Single ownership, cannot be cloned
• Reusability: Can be called multiple times (each call consumes its input)
• Thread Safety: Not thread-safe (no Send + Sync requirement)
• Statefulness: Can modify internal state between calls

Author

Haixing Hu

Implementations

impl<T, R> BoxMapper<T, R>

where T: 'static, R: 'static,

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

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

Creates a new BoxMapper

Parameters

• f - The closure or function to wrap

Examples

use prism3_function::{BoxMapper, Mapper};

let mut counter = 0;
let mut mapper = BoxMapper::new(move |x: i32| {
    counter += 1;
    x + counter
});
assert_eq!(mapper.apply(10), 11);
assert_eq!(mapper.apply(10), 12);

Examples found in repository

examples/mapper_demo.rs (lines 23-26)

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

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

Creates an identity mapper

Examples

use prism3_function::{BoxMapper, Mapper};

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

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

where S: 'static, F: Mapper<R, S> + '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.

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. Note: This parameter is passed by value and will transfer ownership. If you need to preserve the original mapper, clone it first (if it implements Clone). 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 representing the composition

Examples

use prism3_function::{BoxMapper, Mapper};

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);
assert_eq!(composed.apply(10), 11);  // (10 + 1) * 1
assert_eq!(composed.apply(10), 24);  // (10 + 2) * 2

Examples found in repository

examples/mapper_demo.rs (line 46)

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

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

where S: 'static, F: Mapper<S, T> + '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.

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. Note: This parameter is passed by value and will transfer ownership. If you need to preserve the original mapper, clone it first (if it implements Clone). 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 representing the composition

Examples

use prism3_function::{BoxMapper, Mapper};

let mut counter = 0;
let mapper = BoxMapper::new(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
assert_eq!(composed.apply(10), 22); // (10 + 1) * 2

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

where P: Predicate<T> + '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. 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 BoxConditionalMapper<T, R>

Examples

use prism3_function::{Mapper, BoxMapper};

let mut counter = 0;
let mut mapper = BoxMapper::new(move |x: i32| {
    counter += 1;
    x * 2
})
.when(|x: &i32| *x > 10)
.or_else(|x| x + 1);

assert_eq!(mapper.apply(15), 30);  // 15 > 10, apply * 2
assert_eq!(mapper.apply(5), 6);    // 5 <= 10, apply + 1

Examples found in repository

examples/mapper_demo.rs (line 60)

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

impl<T, R> BoxMapper<T, R>

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

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

Creates a constant mapper

Examples

use prism3_function::{BoxMapper, Mapper};

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

Trait Implementations

impl<T, R> Mapper<T, R> for BoxMapper<T, R>

fn apply(&mut self, input: T) -> R

Applies the mapping to the input value to produce an output value

fn into_box(self) -> BoxMapper<T, R>

where T: 'static, R: 'static,

Converts to BoxMapper

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

where T: 'static, R: 'static,

Converts to RcMapper

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

where T: 'static, R: 'static,

Converts to a closure implementing FnMut(T) -> R

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

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

Converts to ArcMapper

impl<T, R> MapperOnce<T, R> for BoxMapper<T, R>

where T: 'static, R: 'static,

fn apply_once(self, input: T) -> R

Applies the mapping to the input value, consuming both self and input

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

where Self: Sized + 'static,

Converts to BoxMapperOnce

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

where Self: Sized + 'static,

Converts mapper to a closure