Struct BoxTransformerOnce 

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

BoxTransformerOnce - consuming transformer wrapper based on Box<dyn FnOnce>

A transformer 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

Hu Haixing

Implementations

impl<T, R> BoxTransformerOnce<T, R>

where T: 'static, R: 'static,

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

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

Creates a new BoxTransformerOnce

Parameters

• f - The closure or function to wrap

Examples

use prism3_function::{BoxTransformerOnce, TransformerOnce};

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

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

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

Creates an identity transformer

Examples

use prism3_function::{BoxTransformerOnce, TransformerOnce};

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

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

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

Chain composition - applies self first, then after

Type Parameters

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

Parameters

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

Returns

A new BoxTransformerOnce representing the composition

Examples

use prism3_function::{BoxTransformerOnce, TransformerOnce};

let add_one = BoxTransformerOnce::new(|x: i32| x + 1);
let double = BoxTransformerOnce::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/fn_transformer_once_ops_demo.rs (line 35)

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

    // 1. Basic and_then composition
    println!("1. Basic and_then composition:");
    let parse = |s: String| s.parse::<i32>().unwrap_or(0);
    let double = |x: i32| x * 2;
    let composed = parse.and_then(double);
    println!(
        "   parse.and_then(double).apply_once(\"21\") = {}",
        composed.apply_once("21".to_string())
    );
    println!();

    // 2. Chained and_then composition
    println!("2. Chained and_then composition:");
    let parse = |s: String| s.parse::<i32>().unwrap_or(0);
    let add_one = |x: i32| x + 1;
    let double = |x: i32| x * 2;
    let chained = parse.and_then(add_one).and_then(double);
    println!(
        "   parse.and_then(add_one).and_then(double).apply_once(\"5\") = {}",
        chained.apply_once("5".to_string())
    ); // (5 + 1) * 2 = 12
    println!();

    // 3. compose reverse composition
    println!("3. compose reverse composition:");
    let double = |x: i32| x * 2;
    let to_string = |x: i32| x.to_string();
    let composed = to_string.compose(double);
    println!(
        "   to_string.compose(double).apply_once(21) = {}",
        composed.apply_once(21)
    ); // (21 * 2).to_string() = "42"
    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_once(5)); // 10

    let double2 = |x: i32| x * 2;
    let conditional2 = double2.when(|x: &i32| *x > 0).or_else(|x: i32| -x);
    println!("     transform(-5) = {}", conditional2.apply_once(-5)); // 5
    println!();

    // 5. Complex composition
    println!("5. Complex composition:");
    let parse = |s: String| s.parse::<i32>().unwrap_or(0);
    let double = |x: i32| x * 2;
    let triple = |x: i32| x * 3;
    let to_string = |x: i32| x.to_string();

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

    println!("   parse.and_then(double.when(x > 5).or_else(triple)).and_then(to_string):");
    println!(
        "     transform(\"3\") = {}",
        complex.apply_once("3".to_string())
    ); // 3 <= 5, so 3 * 3 = 9

    let parse2 = |s: String| s.parse::<i32>().unwrap_or(0);
    let double2 = |x: i32| x * 2;
    let triple2 = |x: i32| x * 3;
    let to_string2 = |x: i32| x.to_string();
    let complex2 = parse2
        .and_then(double2.when(|x: &i32| *x > 5).or_else(triple2))
        .and_then(to_string2);
    println!(
        "     transform(\"10\") = {}",
        complex2.apply_once("10".to_string())
    ); // 10 > 5, so 10 * 2 = 20
    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_once(12345) = {}",
        length_transformer.apply_once(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_once(5) = {}",
        with_capture.apply_once(5)
    ); // 5 * 3 + 10 = 25
    println!();

    // 8. Function pointers
    println!("8. Function pointers:");
    fn parse_fn(s: String) -> i32 {
        s.parse().unwrap_or(0)
    }
    fn double_fn(x: i32) -> i32 {
        x * 2
    }
    let fn_composed = parse_fn.and_then(double_fn);
    println!(
        "   parse_fn.and_then(double_fn).apply_once(\"21\") = {}",
        fn_composed.apply_once("21".to_string())
    ); // 42
    println!();

    // 9. String operations that consume ownership
    println!("9. String operations that consume ownership:");
    let owned = String::from("hello");
    let append = move |s: String| format!("{} {}", s, owned);
    let uppercase = |s: String| s.to_uppercase();
    let composed = append.and_then(uppercase);
    println!(
        "   append.and_then(uppercase).apply_once(\"world\") = {}",
        composed.apply_once("world".to_string())
    ); // "WORLD HELLO"
    println!();

    // 10. Parsing and validation
    println!("10. Parsing and validation:");
    let parse = |s: String| s.parse::<i32>().unwrap_or(0);
    let validate = |x: i32| if x > 0 { x } else { 1 };
    let composed = parse.and_then(validate);
    println!(
        "   parse.and_then(validate).apply_once(\"42\") = {}",
        composed.apply_once("42".to_string())
    ); // 42

    let parse2 = |s: String| s.parse::<i32>().unwrap_or(0);
    let validate2 = |x: i32| if x > 0 { x } else { 1 };
    let composed2 = parse2.and_then(validate2);
    println!(
        "   parse.and_then(validate).apply_once(\"-5\") = {}",
        composed2.apply_once("-5".to_string())
    ); // 1
    println!();

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

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

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

Reverse composition - applies before first, then self

Type Parameters

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

Parameters

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

Returns

A new BoxTransformerOnce representing the composition

Examples

use prism3_function::{BoxTransformerOnce, TransformerOnce};

let double = BoxTransformerOnce::new(|x: i32| x * 2);
let add_one = BoxTransformerOnce::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

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

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

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

Examples

Basic usage with or_else

use prism3_function::{TransformerOnce, BoxTransformerOnce};

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

let double2 = BoxTransformerOnce::new(|x: i32| x * 2);
let identity2 = BoxTransformerOnce::<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::{TransformerOnce, BoxTransformerOnce, RcPredicate};

let double = BoxTransformerOnce::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(BoxTransformerOnce::identity());

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

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

impl<T, R> BoxTransformerOnce<T, R>

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

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

Creates a constant transformer

Examples

use prism3_function::{BoxTransformerOnce, TransformerOnce};

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

Trait Implementations

impl<T, R> TransformerOnce<T, R> for BoxTransformerOnce<T, R>

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

Transforms the input value, consuming both self and input

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

where T: 'static, R: 'static,

Converts to BoxTransformerOnce

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

where T: 'static, R: 'static,

Converts transformer to a closure