Struct BoxConditionalBiFunction

Source

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

Expand description

BoxConditionalBiFunction struct

A conditional bi-function that only executes when a bi-predicate is satisfied. Uses BoxBiFunction and BoxBiPredicate for single ownership semantics.

This type is typically created by calling BoxBiFunction::when() and is designed to work with the or_else() method to create if-then-else logic.

§Features

Single Ownership: Not cloneable, consumes self on use
Conditional Execution: Only computes when bi-predicate returns true
Chainable: Can add or_else branch to create if-then-else logic
Implements BiFunction: Can be used anywhere a BiFunction is expected

§Examples

§With or_else Branch

use prism3_function::{BiFunction, BoxBiFunction};

let add = BoxBiFunction::new(|x: &i32, y: &i32| *x + *y);
let multiply = BoxBiFunction::new(|x: &i32, y: &i32| *x * *y);
let conditional = add.when(|x: &i32, y: &i32| *x > 0).or_else(multiply);

assert_eq!(conditional.apply(&5, &3), 8);  // when branch executed
assert_eq!(conditional.apply(&-5, &3), -15); // or_else branch executed

§Author

Haixing Hu

Implementations§

Source §

impl<T, U, R> BoxConditionalBiFunction<T, U, R>
where T: 'static, U: 'static, R: 'static,

Source

pub fn or_else<F>(self, else_function: F) -> BoxBiFunction<T, U, R>
where F: BiFunction<T, U, R> + 'static,

Provides an alternative function for when the predicate is not satisfied

Combines the current conditional bifunction with an alternative bifunction into a new bifunction that implements the following semantics:

When the returned bifunction is called with two arguments:

If the predicate is satisfied, it executes the internal bifunction
If the predicate is NOT satisfied, it executes the alternative bifunction

§Parameters

else_function - The alternative bifunction to execute when predicate fails

§Returns

Returns a new bifunction that handles both conditional branches

§Examples

let func = BoxBiFunction::new(|x: i32, y: i32| x + y);
let alternative = BoxBiFunction::new(|x: i32, y: i32| x * y);

let conditional = func.when(|x, y| *x > 0 && *y > 0).or_else(alternative);

assert_eq!(conditional.apply(3, 4), 7);   // 3 + 4 = 7 (predicate satisfied)
assert_eq!(conditional.apply(-2, 4), -8); // -2 * 4 = -8 (predicate failed)