Trait MapperOnce 

pub trait MapperOnce<T, R> {
    // Required method
    fn apply_once(self, input: T) -> R;

    // Provided methods
    fn into_box_once(self) -> BoxMapperOnce<T, R>
       where Self: Sized + 'static,
             T: 'static,
             R: 'static { ... }
    fn into_fn_once(self) -> impl FnOnce(T) -> R
       where Self: Sized + 'static,
             T: 'static,
             R: 'static { ... }
    fn to_box_once(&self) -> BoxMapperOnce<T, R>
       where Self: Clone + 'static,
             T: 'static,
             R: 'static { ... }
    fn to_fn_once(&self) -> impl FnOnce(T) -> R
       where Self: Clone + 'static,
             T: 'static,
             R: 'static { ... }
}

MapperOnce trait - consuming mapper that takes ownership

Defines the behavior of a consuming mapper: converting a value of type T to a value of type R by taking ownership of both self and the input. This trait is analogous to FnOnce(T) -> R.

Unlike Mapper (which is like FnMut), MapperOnce consumes itself on the first call, making it suitable for one-time transformations that may own or consume resources.

Type Parameters

• T - The type of the input value (consumed)
• R - The type of the output value

Author

胡海星

Required Methods

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

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

Parameters

• input - The input value (consumed)

Returns

The mapped output value

Provided Methods

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

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

Converts to BoxMapperOnce

⚠️ Consumes self: The original mapper becomes unavailable after calling this method.

Returns

Returns BoxMapperOnce<T, R>

Examples

use prism3_function::MapperOnce;

let double = |x: i32| x * 2;
let boxed = double.into_box_once();
assert_eq!(boxed.apply_once(21), 42);

Examples found in repository

examples/mapper_demo.rs (line 179)

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 into_fn_once(self) -> impl FnOnce(T) -> R

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

Converts mapper to a closure

⚠️ Consumes self: The original mapper becomes unavailable after calling this method.

Returns

Returns a closure that implements FnOnce(T) -> R

Examples

use prism3_function::MapperOnce;

let double = |x: i32| x * 2;
let func = double.into_fn_once();
assert_eq!(func(21), 42);

fn to_box_once(&self) -> BoxMapperOnce<T, R>

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

Converts to BoxMapperOnce without consuming self

📌 Borrows &self: The original mapper remains usable after calling this method.

Default Implementation

The default implementation creates a new BoxMapperOnce that captures a clone. Types implementing Clone can override this method to provide more efficient conversions.

Returns

Returns BoxMapperOnce<T, R>

Examples

use prism3_function::MapperOnce;

let double = |x: i32| x * 2;
let boxed = double.to_box_once();
assert_eq!(boxed.apply_once(21), 42);

Examples found in repository

examples/mapper_demo.rs (line 188)

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 to_fn_once(&self) -> impl FnOnce(T) -> R

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

Converts mapper to a closure without consuming self

📌 Borrows &self: The original mapper remains usable after calling this method.

Default Implementation

The default implementation creates a closure that captures a clone of self and calls its apply method. Types can override this method to provide more efficient conversions.

Returns

Returns a closure that implements FnOnce(T) -> R

Examples

use prism3_function::MapperOnce;

let double = |x: i32| x * 2;
let func = double.to_fn_once();
assert_eq!(func(21), 42);

Implementors

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

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

Implement MapperOnce<T, R> for any type that implements FnOnce(T) -> R

This allows once-callable closures and function pointers to be used directly with our MapperOnce trait without wrapping.

Examples

use prism3_function::MapperOnce;

fn parse(s: String) -> i32 {
    s.parse().unwrap_or(0)
}

assert_eq!(parse.apply_once("42".to_string()), 42);

let owned_value = String::from("hello");
let consume = |s: String| {
    format!("{} world", s)
};
assert_eq!(consume.apply_once(owned_value), "hello world");

Author

胡海星

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

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

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

where T: 'static, R: 'static,

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

where T: 'static, R: 'static,

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