Struct BoxMapperOnce 

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

BoxMapperOnce - consuming mapper wrapper based on Box<dyn FnOnce>

A mapper wrapper that provides single ownership with one-time use semantics. Consumes both self and the input value.

Features

• Based on: Box<dyn FnOnce(T) -> R>
• Ownership: Single ownership, cannot be cloned
• Reusability: Can only be called once (consumes self and input)
• Thread Safety: Not thread-safe (no Send + Sync requirement)

Author

胡海星

Implementations

impl<T, R> BoxMapperOnce<T, R>

where T: 'static, R: 'static,

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

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

Creates a new BoxMapperOnce

Parameters

• f - The closure or function to wrap

Examples

use prism3_function::{BoxMapperOnce, MapperOnce};

let parse = BoxMapperOnce::new(|s: String| {
    s.parse::<i32>().unwrap_or(0)
});

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

Examples found in repository

examples/mapper_once_demo.rs (line 17)

fn main() {
    println!("=== MapperOnce 演示 ===\n");

    // 1. 基本的 BoxMapperOnce
    println!("1. 基本的 BoxMapperOnce");
    let parse = BoxMapperOnce::new(|s: String| s.parse::<i32>().unwrap_or(0));
    let result = parse.apply_once("42".to_string());
    println!("   解析 '42': {}", result);

    // 2. identity mapper
    println!("\n2. Identity Mapper");
    let identity = BoxMapperOnce::<i32, i32>::identity();
    let result = identity.apply_once(42);
    println!("   identity(42): {}", result);

    // 3. constant mapper
    println!("\n3. Constant Mapper");
    let constant = BoxMapperOnce::constant("hello");
    let result = constant.apply_once(123);
    println!("   constant(123): {}", result);

    // 4. and_then 组合
    println!("\n4. and_then 组合");
    let add_one = BoxMapperOnce::new(|x: i32| x + 1);
    let double = |x: i32| x * 2;
    let composed = add_one.and_then(double);
    let result = composed.apply_once(5);
    println!("   (5 + 1) * 2 = {}", result);

    // 5. compose 组合
    println!("\n5. compose 组合");
    let double = BoxMapperOnce::new(|x: i32| x * 2);
    let add_one = |x: i32| x + 1;
    let composed = double.compose(add_one);
    let result = composed.apply_once(5);
    println!("   double(5 + 1) = {}", result);

    // 6. 条件映射
    println!("\n6. 条件映射");
    let double = BoxMapperOnce::new(|x: i32| x * 2);
    let conditional = double.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
    let result1 = conditional.apply_once(5);
    println!("   条件(5 > 0): double(5) = {}", result1);

    let double2 = BoxMapperOnce::new(|x: i32| x * 2);
    let conditional2 = double2.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
    let result2 = conditional2.apply_once(-5);
    println!("   条件(-5 > 0): negate(-5) = {}", result2);

    // 7. 管道操作
    println!("\n7. 管道操作");
    let add_one = BoxMapperOnce::new(|x: i32| x + 1);
    let pipeline = add_one.and_then(|x| x * 2).and_then(|x| x - 3);
    let result = pipeline.apply_once(5);
    println!("   ((5 + 1) * 2) - 3 = {}", result);

    // 8. 闭包扩展方法
    println!("\n8. 闭包扩展方法 (FnMapperOnceOps)");
    let parse = |s: String| s.parse::<i32>().unwrap_or(0);
    let double = |x: i32| x * 2;
    let composed = parse.and_then(double);
    let result = composed.apply_once("21".to_string());
    println!("   parse('21') * 2 = {}", result);

    // 9. 类型转换
    println!("\n9. 类型转换");
    let to_string = BoxMapperOnce::new(|x: i32| x.to_string());
    let add_suffix = to_string.and_then(|s| format!("{}_suffix", s));
    let result = add_suffix.apply_once(42);
    println!("   42.to_string() + '_suffix' = {}", result);

    // 10. 消费所有权
    println!("\n10. 消费所有权");
    let vec = vec![1, 2, 3, 4, 5];
    let sum = BoxMapperOnce::new(|v: Vec<i32>| v.iter().sum::<i32>());
    let result = sum.apply_once(vec);
    println!("   sum([1,2,3,4,5]) = {}", result);

    println!("\n=== MapperOnce 演示完成 ===");
}

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

Creates an identity mapper

Examples

use prism3_function::{BoxMapperOnce, MapperOnce};

let identity = BoxMapperOnce::<i32, i32>::identity();
assert_eq!(identity.apply_once(42), 42);

Examples found in repository

examples/mapper_once_demo.rs (line 23)

fn main() {
    println!("=== MapperOnce 演示 ===\n");

    // 1. 基本的 BoxMapperOnce
    println!("1. 基本的 BoxMapperOnce");
    let parse = BoxMapperOnce::new(|s: String| s.parse::<i32>().unwrap_or(0));
    let result = parse.apply_once("42".to_string());
    println!("   解析 '42': {}", result);

    // 2. identity mapper
    println!("\n2. Identity Mapper");
    let identity = BoxMapperOnce::<i32, i32>::identity();
    let result = identity.apply_once(42);
    println!("   identity(42): {}", result);

    // 3. constant mapper
    println!("\n3. Constant Mapper");
    let constant = BoxMapperOnce::constant("hello");
    let result = constant.apply_once(123);
    println!("   constant(123): {}", result);

    // 4. and_then 组合
    println!("\n4. and_then 组合");
    let add_one = BoxMapperOnce::new(|x: i32| x + 1);
    let double = |x: i32| x * 2;
    let composed = add_one.and_then(double);
    let result = composed.apply_once(5);
    println!("   (5 + 1) * 2 = {}", result);

    // 5. compose 组合
    println!("\n5. compose 组合");
    let double = BoxMapperOnce::new(|x: i32| x * 2);
    let add_one = |x: i32| x + 1;
    let composed = double.compose(add_one);
    let result = composed.apply_once(5);
    println!("   double(5 + 1) = {}", result);

    // 6. 条件映射
    println!("\n6. 条件映射");
    let double = BoxMapperOnce::new(|x: i32| x * 2);
    let conditional = double.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
    let result1 = conditional.apply_once(5);
    println!("   条件(5 > 0): double(5) = {}", result1);

    let double2 = BoxMapperOnce::new(|x: i32| x * 2);
    let conditional2 = double2.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
    let result2 = conditional2.apply_once(-5);
    println!("   条件(-5 > 0): negate(-5) = {}", result2);

    // 7. 管道操作
    println!("\n7. 管道操作");
    let add_one = BoxMapperOnce::new(|x: i32| x + 1);
    let pipeline = add_one.and_then(|x| x * 2).and_then(|x| x - 3);
    let result = pipeline.apply_once(5);
    println!("   ((5 + 1) * 2) - 3 = {}", result);

    // 8. 闭包扩展方法
    println!("\n8. 闭包扩展方法 (FnMapperOnceOps)");
    let parse = |s: String| s.parse::<i32>().unwrap_or(0);
    let double = |x: i32| x * 2;
    let composed = parse.and_then(double);
    let result = composed.apply_once("21".to_string());
    println!("   parse('21') * 2 = {}", result);

    // 9. 类型转换
    println!("\n9. 类型转换");
    let to_string = BoxMapperOnce::new(|x: i32| x.to_string());
    let add_suffix = to_string.and_then(|s| format!("{}_suffix", s));
    let result = add_suffix.apply_once(42);
    println!("   42.to_string() + '_suffix' = {}", result);

    // 10. 消费所有权
    println!("\n10. 消费所有权");
    let vec = vec![1, 2, 3, 4, 5];
    let sum = BoxMapperOnce::new(|v: Vec<i32>| v.iter().sum::<i32>());
    let result = sum.apply_once(vec);
    println!("   sum([1,2,3,4,5]) = {}", result);

    println!("\n=== MapperOnce 演示完成 ===");
}

pub fn and_then<S, G>(self, after: G) -> BoxMapperOnce<T, S>

where S: 'static, G: MapperOnce<R, S> + 'static,

Chain composition - applies self first, then after

Type Parameters

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

Parameters

• after - The mapper to apply after self. Note: This parameter is passed by value and will transfer ownership. Since BoxMapperOnce cannot be cloned, the parameter will be consumed. Can be:
  • A closure: |x: R| -> S
  • A function pointer: fn(R) -> S
  • A BoxMapperOnce<R, S>
  • Any type implementing MapperOnce<R, S>

Returns

A new BoxMapperOnce representing the composition

Examples

use prism3_function::{BoxMapperOnce, MapperOnce};

let add_one = BoxMapperOnce::new(|x: i32| x + 1);
let double = BoxMapperOnce::new(|x: i32| x * 2);

// Both add_one and double are moved and consumed
let composed = add_one.and_then(double);
assert_eq!(composed.apply_once(5), 12); // (5 + 1) * 2
// add_one.apply_once(3); // Would not compile - moved
// double.apply_once(4);  // Would not compile - moved

Examples found in repository

examples/mapper_once_demo.rs (line 37)

fn main() {
    println!("=== MapperOnce 演示 ===\n");

    // 1. 基本的 BoxMapperOnce
    println!("1. 基本的 BoxMapperOnce");
    let parse = BoxMapperOnce::new(|s: String| s.parse::<i32>().unwrap_or(0));
    let result = parse.apply_once("42".to_string());
    println!("   解析 '42': {}", result);

    // 2. identity mapper
    println!("\n2. Identity Mapper");
    let identity = BoxMapperOnce::<i32, i32>::identity();
    let result = identity.apply_once(42);
    println!("   identity(42): {}", result);

    // 3. constant mapper
    println!("\n3. Constant Mapper");
    let constant = BoxMapperOnce::constant("hello");
    let result = constant.apply_once(123);
    println!("   constant(123): {}", result);

    // 4. and_then 组合
    println!("\n4. and_then 组合");
    let add_one = BoxMapperOnce::new(|x: i32| x + 1);
    let double = |x: i32| x * 2;
    let composed = add_one.and_then(double);
    let result = composed.apply_once(5);
    println!("   (5 + 1) * 2 = {}", result);

    // 5. compose 组合
    println!("\n5. compose 组合");
    let double = BoxMapperOnce::new(|x: i32| x * 2);
    let add_one = |x: i32| x + 1;
    let composed = double.compose(add_one);
    let result = composed.apply_once(5);
    println!("   double(5 + 1) = {}", result);

    // 6. 条件映射
    println!("\n6. 条件映射");
    let double = BoxMapperOnce::new(|x: i32| x * 2);
    let conditional = double.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
    let result1 = conditional.apply_once(5);
    println!("   条件(5 > 0): double(5) = {}", result1);

    let double2 = BoxMapperOnce::new(|x: i32| x * 2);
    let conditional2 = double2.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
    let result2 = conditional2.apply_once(-5);
    println!("   条件(-5 > 0): negate(-5) = {}", result2);

    // 7. 管道操作
    println!("\n7. 管道操作");
    let add_one = BoxMapperOnce::new(|x: i32| x + 1);
    let pipeline = add_one.and_then(|x| x * 2).and_then(|x| x - 3);
    let result = pipeline.apply_once(5);
    println!("   ((5 + 1) * 2) - 3 = {}", result);

    // 8. 闭包扩展方法
    println!("\n8. 闭包扩展方法 (FnMapperOnceOps)");
    let parse = |s: String| s.parse::<i32>().unwrap_or(0);
    let double = |x: i32| x * 2;
    let composed = parse.and_then(double);
    let result = composed.apply_once("21".to_string());
    println!("   parse('21') * 2 = {}", result);

    // 9. 类型转换
    println!("\n9. 类型转换");
    let to_string = BoxMapperOnce::new(|x: i32| x.to_string());
    let add_suffix = to_string.and_then(|s| format!("{}_suffix", s));
    let result = add_suffix.apply_once(42);
    println!("   42.to_string() + '_suffix' = {}", result);

    // 10. 消费所有权
    println!("\n10. 消费所有权");
    let vec = vec![1, 2, 3, 4, 5];
    let sum = BoxMapperOnce::new(|v: Vec<i32>| v.iter().sum::<i32>());
    let result = sum.apply_once(vec);
    println!("   sum([1,2,3,4,5]) = {}", result);

    println!("\n=== MapperOnce 演示完成 ===");
}

pub fn compose<S, G>(self, before: G) -> BoxMapperOnce<S, R>

where S: 'static, G: MapperOnce<S, T> + 'static,

Reverse composition - applies before first, then self

Type Parameters

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

Parameters

• before - The mapper to apply before self. Note: This parameter is passed by value and will transfer ownership. Since BoxMapperOnce cannot be cloned, the parameter will be consumed. Can be:
  • A closure: |x: S| -> T
  • A function pointer: fn(S) -> T
  • A BoxMapperOnce<S, T>
  • Any type implementing MapperOnce<S, T>

Returns

A new BoxMapperOnce representing the composition

Examples

use prism3_function::{BoxMapperOnce, MapperOnce};

let double = BoxMapperOnce::new(|x: i32| x * 2);
let add_one = BoxMapperOnce::new(|x: i32| x + 1);

// Both double and add_one are moved and consumed
let composed = double.compose(add_one);
assert_eq!(composed.apply_once(5), 12); // (5 + 1) * 2
// double.apply_once(3); // Would not compile - moved
// add_one.apply_once(4); // Would not compile - moved

Examples found in repository

examples/mapper_once_demo.rs (line 45)

fn main() {
    println!("=== MapperOnce 演示 ===\n");

    // 1. 基本的 BoxMapperOnce
    println!("1. 基本的 BoxMapperOnce");
    let parse = BoxMapperOnce::new(|s: String| s.parse::<i32>().unwrap_or(0));
    let result = parse.apply_once("42".to_string());
    println!("   解析 '42': {}", result);

    // 2. identity mapper
    println!("\n2. Identity Mapper");
    let identity = BoxMapperOnce::<i32, i32>::identity();
    let result = identity.apply_once(42);
    println!("   identity(42): {}", result);

    // 3. constant mapper
    println!("\n3. Constant Mapper");
    let constant = BoxMapperOnce::constant("hello");
    let result = constant.apply_once(123);
    println!("   constant(123): {}", result);

    // 4. and_then 组合
    println!("\n4. and_then 组合");
    let add_one = BoxMapperOnce::new(|x: i32| x + 1);
    let double = |x: i32| x * 2;
    let composed = add_one.and_then(double);
    let result = composed.apply_once(5);
    println!("   (5 + 1) * 2 = {}", result);

    // 5. compose 组合
    println!("\n5. compose 组合");
    let double = BoxMapperOnce::new(|x: i32| x * 2);
    let add_one = |x: i32| x + 1;
    let composed = double.compose(add_one);
    let result = composed.apply_once(5);
    println!("   double(5 + 1) = {}", result);

    // 6. 条件映射
    println!("\n6. 条件映射");
    let double = BoxMapperOnce::new(|x: i32| x * 2);
    let conditional = double.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
    let result1 = conditional.apply_once(5);
    println!("   条件(5 > 0): double(5) = {}", result1);

    let double2 = BoxMapperOnce::new(|x: i32| x * 2);
    let conditional2 = double2.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
    let result2 = conditional2.apply_once(-5);
    println!("   条件(-5 > 0): negate(-5) = {}", result2);

    // 7. 管道操作
    println!("\n7. 管道操作");
    let add_one = BoxMapperOnce::new(|x: i32| x + 1);
    let pipeline = add_one.and_then(|x| x * 2).and_then(|x| x - 3);
    let result = pipeline.apply_once(5);
    println!("   ((5 + 1) * 2) - 3 = {}", result);

    // 8. 闭包扩展方法
    println!("\n8. 闭包扩展方法 (FnMapperOnceOps)");
    let parse = |s: String| s.parse::<i32>().unwrap_or(0);
    let double = |x: i32| x * 2;
    let composed = parse.and_then(double);
    let result = composed.apply_once("21".to_string());
    println!("   parse('21') * 2 = {}", result);

    // 9. 类型转换
    println!("\n9. 类型转换");
    let to_string = BoxMapperOnce::new(|x: i32| x.to_string());
    let add_suffix = to_string.and_then(|s| format!("{}_suffix", s));
    let result = add_suffix.apply_once(42);
    println!("   42.to_string() + '_suffix' = {}", result);

    // 10. 消费所有权
    println!("\n10. 消费所有权");
    let vec = vec![1, 2, 3, 4, 5];
    let sum = BoxMapperOnce::new(|v: Vec<i32>| v.iter().sum::<i32>());
    let result = sum.apply_once(vec);
    println!("   sum([1,2,3,4,5]) = {}", result);

    println!("\n=== MapperOnce 演示完成 ===");
}

pub fn when<P>(self, predicate: P) -> BoxConditionalMapperOnce<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.

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 BoxConditionalMapperOnce<T, R>

Examples

Basic usage with or_else

use prism3_function::{MapperOnce, BoxMapperOnce};

let double = BoxMapperOnce::new(|x: i32| x * 2);
let identity = BoxMapperOnce::<i32, i32>::identity();
let conditional = double.when(|x: &i32| *x > 0).or_else(identity);
assert_eq!(conditional.apply_once(5), 10);

let double2 = BoxMapperOnce::new(|x: i32| x * 2);
let identity2 = BoxMapperOnce::<i32, i32>::identity();
let conditional2 = double2.when(|x: &i32| *x > 0).or_else(identity2);
assert_eq!(conditional2.apply_once(-5), -5);

Preserving predicate with clone

use prism3_function::{MapperOnce, BoxMapperOnce, RcPredicate, Predicate};

let double = BoxMapperOnce::new(|x: i32| x * 2);
let is_positive = RcPredicate::new(|x: &i32| *x > 0);

// Clone to preserve original predicate
let conditional = double.when(is_positive.clone())
    .or_else(BoxMapperOnce::<i32, i32>::identity());

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

// Original predicate still usable
assert!(is_positive.test(&3));

Examples found in repository

examples/mapper_once_demo.rs (line 52)

fn main() {
    println!("=== MapperOnce 演示 ===\n");

    // 1. 基本的 BoxMapperOnce
    println!("1. 基本的 BoxMapperOnce");
    let parse = BoxMapperOnce::new(|s: String| s.parse::<i32>().unwrap_or(0));
    let result = parse.apply_once("42".to_string());
    println!("   解析 '42': {}", result);

    // 2. identity mapper
    println!("\n2. Identity Mapper");
    let identity = BoxMapperOnce::<i32, i32>::identity();
    let result = identity.apply_once(42);
    println!("   identity(42): {}", result);

    // 3. constant mapper
    println!("\n3. Constant Mapper");
    let constant = BoxMapperOnce::constant("hello");
    let result = constant.apply_once(123);
    println!("   constant(123): {}", result);

    // 4. and_then 组合
    println!("\n4. and_then 组合");
    let add_one = BoxMapperOnce::new(|x: i32| x + 1);
    let double = |x: i32| x * 2;
    let composed = add_one.and_then(double);
    let result = composed.apply_once(5);
    println!("   (5 + 1) * 2 = {}", result);

    // 5. compose 组合
    println!("\n5. compose 组合");
    let double = BoxMapperOnce::new(|x: i32| x * 2);
    let add_one = |x: i32| x + 1;
    let composed = double.compose(add_one);
    let result = composed.apply_once(5);
    println!("   double(5 + 1) = {}", result);

    // 6. 条件映射
    println!("\n6. 条件映射");
    let double = BoxMapperOnce::new(|x: i32| x * 2);
    let conditional = double.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
    let result1 = conditional.apply_once(5);
    println!("   条件(5 > 0): double(5) = {}", result1);

    let double2 = BoxMapperOnce::new(|x: i32| x * 2);
    let conditional2 = double2.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
    let result2 = conditional2.apply_once(-5);
    println!("   条件(-5 > 0): negate(-5) = {}", result2);

    // 7. 管道操作
    println!("\n7. 管道操作");
    let add_one = BoxMapperOnce::new(|x: i32| x + 1);
    let pipeline = add_one.and_then(|x| x * 2).and_then(|x| x - 3);
    let result = pipeline.apply_once(5);
    println!("   ((5 + 1) * 2) - 3 = {}", result);

    // 8. 闭包扩展方法
    println!("\n8. 闭包扩展方法 (FnMapperOnceOps)");
    let parse = |s: String| s.parse::<i32>().unwrap_or(0);
    let double = |x: i32| x * 2;
    let composed = parse.and_then(double);
    let result = composed.apply_once("21".to_string());
    println!("   parse('21') * 2 = {}", result);

    // 9. 类型转换
    println!("\n9. 类型转换");
    let to_string = BoxMapperOnce::new(|x: i32| x.to_string());
    let add_suffix = to_string.and_then(|s| format!("{}_suffix", s));
    let result = add_suffix.apply_once(42);
    println!("   42.to_string() + '_suffix' = {}", result);

    // 10. 消费所有权
    println!("\n10. 消费所有权");
    let vec = vec![1, 2, 3, 4, 5];
    let sum = BoxMapperOnce::new(|v: Vec<i32>| v.iter().sum::<i32>());
    let result = sum.apply_once(vec);
    println!("   sum([1,2,3,4,5]) = {}", result);

    println!("\n=== MapperOnce 演示完成 ===");
}

impl<T, R> BoxMapperOnce<T, R>

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

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

Creates a constant mapper

Examples

use prism3_function::{BoxMapperOnce, MapperOnce};

let constant = BoxMapperOnce::constant("hello");
assert_eq!(constant.apply_once(123), "hello");

Examples found in repository

examples/mapper_once_demo.rs (line 29)

fn main() {
    println!("=== MapperOnce 演示 ===\n");

    // 1. 基本的 BoxMapperOnce
    println!("1. 基本的 BoxMapperOnce");
    let parse = BoxMapperOnce::new(|s: String| s.parse::<i32>().unwrap_or(0));
    let result = parse.apply_once("42".to_string());
    println!("   解析 '42': {}", result);

    // 2. identity mapper
    println!("\n2. Identity Mapper");
    let identity = BoxMapperOnce::<i32, i32>::identity();
    let result = identity.apply_once(42);
    println!("   identity(42): {}", result);

    // 3. constant mapper
    println!("\n3. Constant Mapper");
    let constant = BoxMapperOnce::constant("hello");
    let result = constant.apply_once(123);
    println!("   constant(123): {}", result);

    // 4. and_then 组合
    println!("\n4. and_then 组合");
    let add_one = BoxMapperOnce::new(|x: i32| x + 1);
    let double = |x: i32| x * 2;
    let composed = add_one.and_then(double);
    let result = composed.apply_once(5);
    println!("   (5 + 1) * 2 = {}", result);

    // 5. compose 组合
    println!("\n5. compose 组合");
    let double = BoxMapperOnce::new(|x: i32| x * 2);
    let add_one = |x: i32| x + 1;
    let composed = double.compose(add_one);
    let result = composed.apply_once(5);
    println!("   double(5 + 1) = {}", result);

    // 6. 条件映射
    println!("\n6. 条件映射");
    let double = BoxMapperOnce::new(|x: i32| x * 2);
    let conditional = double.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
    let result1 = conditional.apply_once(5);
    println!("   条件(5 > 0): double(5) = {}", result1);

    let double2 = BoxMapperOnce::new(|x: i32| x * 2);
    let conditional2 = double2.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
    let result2 = conditional2.apply_once(-5);
    println!("   条件(-5 > 0): negate(-5) = {}", result2);

    // 7. 管道操作
    println!("\n7. 管道操作");
    let add_one = BoxMapperOnce::new(|x: i32| x + 1);
    let pipeline = add_one.and_then(|x| x * 2).and_then(|x| x - 3);
    let result = pipeline.apply_once(5);
    println!("   ((5 + 1) * 2) - 3 = {}", result);

    // 8. 闭包扩展方法
    println!("\n8. 闭包扩展方法 (FnMapperOnceOps)");
    let parse = |s: String| s.parse::<i32>().unwrap_or(0);
    let double = |x: i32| x * 2;
    let composed = parse.and_then(double);
    let result = composed.apply_once("21".to_string());
    println!("   parse('21') * 2 = {}", result);

    // 9. 类型转换
    println!("\n9. 类型转换");
    let to_string = BoxMapperOnce::new(|x: i32| x.to_string());
    let add_suffix = to_string.and_then(|s| format!("{}_suffix", s));
    let result = add_suffix.apply_once(42);
    println!("   42.to_string() + '_suffix' = {}", result);

    // 10. 消费所有权
    println!("\n10. 消费所有权");
    let vec = vec![1, 2, 3, 4, 5];
    let sum = BoxMapperOnce::new(|v: Vec<i32>| v.iter().sum::<i32>());
    let result = sum.apply_once(vec);
    println!("   sum([1,2,3,4,5]) = {}", result);

    println!("\n=== MapperOnce 演示完成 ===");
}

Trait Implementations

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

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 T: 'static, R: 'static,

Converts to BoxMapperOnce

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

where T: 'static, R: 'static,

Converts mapper to a closure