Struct BoxPredicate 

pub struct BoxPredicate<T> { /* private fields */ }

A Box-based predicate with single ownership.

This type is suitable for one-time use scenarios where the predicate does not need to be cloned or shared. Composition methods consume self, reflecting the single-ownership model.

Examples

use prism3_function::predicate::{Predicate, BoxPredicate};

let pred = BoxPredicate::new(|x: &i32| *x > 0);
assert!(pred.test(&5));

// Chaining consumes the predicate
let combined = pred.and(BoxPredicate::new(|x| x % 2 == 0));
assert!(combined.test(&4));

Author

Haixing Hu

Implementations

impl<T: 'static> BoxPredicate<T>

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

where F: Fn(&T) -> bool + 'static,

Creates a new BoxPredicate from a closure.

Parameters

• f - The closure to wrap.

Returns

A new BoxPredicate instance.

Examples found in repository

examples/predicate_fn_mut_demo.rs (line 27)

fn demo_with_iterator_filter() {
    println!("1. Using Iterator::filter");

    let pred = BoxPredicate::new(|x: &i32| *x > 0);
    let numbers = vec![-2, -1, 0, 1, 2, 3];
    let positives: Vec<_> = numbers.iter().copied().filter(pred.into_fn()).collect();
    println!("   Original data: {:?}", numbers);
    println!("   Filtered result: {:?}", positives);
    assert_eq!(positives, vec![1, 2, 3]);
    println!("   ✓ BoxPredicate::into_fn() can be used in filter\n");
}

examples/predicate_demo.rs (line 82)

fn box_predicate_examples() {
    println!("--- 2. BoxPredicate Examples (Single Ownership) ---");

    // Basic BoxPredicate
    let pred = BoxPredicate::new(|x: &i32| *x > 0);
    println!("BoxPredicate test 5: {}", pred.test(&5));

    // Named predicate for better debugging
    let named_pred =
        BoxPredicate::new_with_name("is_positive_even", |x: &i32| *x > 0 && x % 2 == 0);
    println!("Predicate name: {:?}", named_pred.name());
    println!("Test 4: {}", named_pred.test(&4));

    // Method chaining - consumes self
    let positive = BoxPredicate::new_with_name("positive", |x: &i32| *x > 0);
    let even = BoxPredicate::new_with_name("even", |x: &i32| x % 2 == 0);
    let combined = positive.and(even);
    println!("Combined predicate name: {:?}", combined.name());
    println!("Test 4: {}", combined.test(&4));
}

/// RcPredicate examples - single-threaded reuse
fn rc_predicate_examples() {
    println!("--- 3. RcPredicate Examples (Single-threaded Reuse) ---");

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

    // Multiple compositions without consuming the original
    let positive_and_even = is_positive.and(is_even.clone());
    let positive_or_even = is_positive.or(is_even.clone());

    println!("Original predicates still available:");
    println!("  is_positive.test(&5) = {}", is_positive.test(&5));
    println!("  is_even.test(&4) = {}", is_even.test(&4));

    println!("Combined predicates:");
    println!(
        "  positive_and_even.test(&4) = {}",
        positive_and_even.test(&4)
    );
    println!(
        "  positive_or_even.test(&5) = {}",
        positive_or_even.test(&5)
    );

    // Cloning
    let cloned = is_positive.clone();
    println!("Cloned predicate: {}", cloned.test(&10));
}

/// ArcPredicate examples - multi-threaded scenarios
fn arc_predicate_examples() {
    println!("--- 4. ArcPredicate Examples (Multi-threaded Scenarios) ---");

    let is_positive = ArcPredicate::new(|x: &i32| *x > 0);
    let is_even = ArcPredicate::new(|x: &i32| x % 2 == 0);

    // Create combined predicate
    let combined = is_positive.and(is_even);

    // Use in multiple threads
    let handles: Vec<_> = (0..3)
        .map(|i| {
            let pred = combined.clone();
            std::thread::spawn(move || {
                let value = i * 2;
                println!("  Thread {} testing {}: {}", i, value, pred.test(&value));
            })
        })
        .collect();

    for handle in handles {
        handle.join().unwrap();
    }

    // Original predicates still usable
    println!("Original predicates still available in main thread:");
    println!("  is_positive.test(&5) = {}", is_positive.test(&5));
}

/// Logical composition examples
fn logical_composition_examples() {
    println!("--- 5. Logical Composition Examples ---");

    let positive = RcPredicate::new_with_name("positive", |x: &i32| *x > 0);
    let even = RcPredicate::new_with_name("even", |x: &i32| x % 2 == 0);
    let less_than_ten = RcPredicate::new_with_name("less_than_ten", |x: &i32| *x < 10);

    // AND composition
    let positive_and_even = positive.and(even.clone());
    println!("positive AND even: name={:?}", positive_and_even.name());
    println!("  Test 4: {}", positive_and_even.test(&4));
    println!("  Test 5: {}", positive_and_even.test(&5));

    // OR composition
    let positive_or_even = positive.or(even.clone());
    println!("positive OR even: name={:?}", positive_or_even.name());
    println!("  Test -2: {}", positive_or_even.test(&-2));
    println!("  Test 5: {}", positive_or_even.test(&5));

    // NOT composition
    let not_positive = positive.not();
    println!("NOT positive: name={:?}", not_positive.name());
    println!("  Test 5: {}", not_positive.test(&5));
    println!("  Test -3: {}", not_positive.test(&-3));

    // NAND composition
    let nand = positive.nand(even.clone());
    println!("positive NAND even: name={:?}", nand.name());
    println!("  Test 3: {}", nand.test(&3)); // true NAND false = true
    println!("  Test 4: {}", nand.test(&4)); // true NAND true = false

    // XOR composition
    let xor = positive.xor(even.clone());
    println!("positive XOR even: name={:?}", xor.name());
    println!("  Test 3: {}", xor.test(&3)); // true XOR false = true
    println!("  Test 4: {}", xor.test(&4)); // true XOR true = false
    println!("  Test -2: {}", xor.test(&-2)); // false XOR true = true

    // NOR composition
    let nor = positive.nor(even.clone());
    println!("positive NOR even: name={:?}", nor.name());
    println!("  Test -3: {}", nor.test(&-3)); // false NOR false = true
    println!("  Test 3: {}", nor.test(&3)); // true NOR false = false
    println!("  Test -2: {}", nor.test(&-2)); // false NOR true = false
    println!("  Test 4: {}", nor.test(&4)); // true NOR true = false

    // Complex composition
    let complex = positive.and(even.clone()).and(less_than_ten.clone());
    println!("Complex composition: name={:?}", complex.name());
    println!("  Test 4: {}", complex.test(&4));
    println!("  Test 12: {}", complex.test(&12));
}

/// Interior mutability examples
fn interior_mutability_examples() {
    println!("--- 6. Interior Mutability Examples ---");

    // BoxPredicate with counter (RefCell)
    println!("BoxPredicate with counter:");
    let count = RefCell::new(0);
    let pred = BoxPredicate::new(move |x: &i32| {
        *count.borrow_mut() += 1;
        *x > 0
    });
    println!("  Test 5: {}", pred.test(&5));
    println!("  Test -3: {}", pred.test(&-3));
    println!("  Test 10: {}", pred.test(&10));
    // Note: count is moved into the closure, so we can't access it here

    // RcPredicate with cache (RefCell + HashMap)
    println!("\nRcPredicate with cache:");
    let cache: RefCell<HashMap<i32, bool>> = RefCell::new(HashMap::new());
    let expensive_pred = RcPredicate::new(move |x: &i32| {
        let mut c = cache.borrow_mut();
        *c.entry(*x).or_insert_with(|| {
            println!("    Computing result for {} (expensive operation)", x);
            *x > 0 && x % 2 == 0
        })
    });

    println!("  First test 4:");
    println!("    Result: {}", expensive_pred.test(&4));
    println!("  Test 4 again (using cache):");
    println!("    Result: {}", expensive_pred.test(&4));
    println!("  Test 3:");
    println!("    Result: {}", expensive_pred.test(&3));

    // ArcPredicate with thread-safe counter (Mutex)
    println!("\nArcPredicate with thread-safe counter:");
    let counter = Arc::new(Mutex::new(0));
    let pred = ArcPredicate::new({
        let counter = Arc::clone(&counter);
        move |x: &i32| {
            let mut c = counter.lock().unwrap();
            *c += 1;
            *x > 0
        }
    });

    let pred_clone = pred.clone();
    let counter_clone = Arc::clone(&counter);

    let handle = std::thread::spawn(move || {
        pred_clone.test(&5);
        pred_clone.test(&10);
    });

    pred.test(&3);
    handle.join().unwrap();

    println!("  Total call count: {}", counter_clone.lock().unwrap());
}

examples/predicate_set_name_demo.rs (line 33)

fn demo_box_predicate() {
    println!("1. BoxPredicate Naming Functionality");

    // Create a predicate with name using new_with_name
    let pred1 = BoxPredicate::new_with_name("is_positive", |x: &i32| *x > 0);
    println!("   Created with new_with_name:");
    println!("     Name: {:?}", pred1.name());
    println!("     Test 5: {}", pred1.test(&5));

    // Set name for an existing predicate using set_name
    let mut pred2 = BoxPredicate::new(|x: &i32| x % 2 == 0);
    println!("\n   Created with new then set_name:");
    println!("     Initial name: {:?}", pred2.name());
    pred2.set_name("is_even");
    println!("     Name after setting: {:?}", pred2.name());
    println!("     Test 4: {}", pred2.test(&4));

    // Combined predicates automatically generate new names
    let pred3 = BoxPredicate::new_with_name("positive", |x: &i32| *x > 0);
    let pred4 = BoxPredicate::new_with_name("even", |x: &i32| x % 2 == 0);
    let combined = pred3.and(pred4);
    println!("\n   Combined predicate name:");
    println!("     Auto-generated name: {:?}", combined.name());
    println!("     Test 4: {}\n", combined.test(&4));
}

examples/always_predicate_demo.rs (line 89)

fn main() {
    println!("=== BoxPredicate always_true/always_false Demo ===\n");

    // BoxPredicate::always_true
    let always_true: BoxPredicate<i32> = BoxPredicate::always_true();
    println!("BoxPredicate::always_true():");
    println!("  test(&42): {}", always_true.test(&42));
    println!("  test(&-1): {}", always_true.test(&-1));
    println!("  test(&0): {}", always_true.test(&0));
    println!("  name: {:?}", always_true.name());

    // BoxPredicate::always_false
    let always_false: BoxPredicate<i32> = BoxPredicate::always_false();
    println!("\nBoxPredicate::always_false():");
    println!("  test(&42): {}", always_false.test(&42));
    println!("  test(&-1): {}", always_false.test(&-1));
    println!("  test(&0): {}", always_false.test(&0));
    println!("  name: {:?}", always_false.name());

    println!("\n=== RcPredicate always_true/always_false Demo ===\n");

    // RcPredicate::always_true
    let rc_always_true: RcPredicate<String> = RcPredicate::always_true();
    println!("RcPredicate::always_true():");
    println!(
        "  test(&\"hello\"): {}",
        rc_always_true.test(&"hello".to_string())
    );
    println!(
        "  test(&\"world\"): {}",
        rc_always_true.test(&"world".to_string())
    );
    println!("  name: {:?}", rc_always_true.name());

    // RcPredicate::always_false
    let rc_always_false: RcPredicate<String> = RcPredicate::always_false();
    println!("\nRcPredicate::always_false():");
    println!(
        "  test(&\"hello\"): {}",
        rc_always_false.test(&"hello".to_string())
    );
    println!(
        "  test(&\"world\"): {}",
        rc_always_false.test(&"world".to_string())
    );
    println!("  name: {:?}", rc_always_false.name());

    // Can be cloned and reused
    let rc_clone = rc_always_true.clone();
    println!("\nAfter cloning, still usable:");
    println!(
        "  Original: test(&\"test\"): {}",
        rc_always_true.test(&"test".to_string())
    );
    println!(
        "  Clone: test(&\"test\"): {}",
        rc_clone.test(&"test".to_string())
    );

    println!("\n=== ArcPredicate always_true/always_false Demo ===\n");

    // ArcPredicate::always_true
    let arc_always_true: ArcPredicate<i32> = ArcPredicate::always_true();
    println!("ArcPredicate::always_true():");
    println!("  test(&100): {}", arc_always_true.test(&100));
    println!("  test(&-100): {}", arc_always_true.test(&-100));
    println!("  name: {:?}", arc_always_true.name());

    // ArcPredicate::always_false
    let arc_always_false: ArcPredicate<i32> = ArcPredicate::always_false();
    println!("\nArcPredicate::always_false():");
    println!("  test(&100): {}", arc_always_false.test(&100));
    println!("  test(&-100): {}", arc_always_false.test(&-100));
    println!("  name: {:?}", arc_always_false.name());

    println!("\n=== Combining with other predicates ===\n");

    // Combining with always_true (AND)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_and_true = is_positive.and(BoxPredicate::always_true());
    println!("is_positive AND always_true:");
    println!(
        "  test(&5): {} (equivalent to is_positive)",
        combined_and_true.test(&5)
    );
    println!(
        "  test(&-3): {} (equivalent to is_positive)",
        combined_and_true.test(&-3)
    );

    // Combining with always_false (AND)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_and_false = is_positive.and(BoxPredicate::always_false());
    println!("\nis_positive AND always_false:");
    println!("  test(&5): {} (always false)", combined_and_false.test(&5));
    println!(
        "  test(&-3): {} (always false)",
        combined_and_false.test(&-3)
    );

    // Combining with always_true (OR)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_or_true = is_positive.or(BoxPredicate::always_true());
    println!("\nis_positive OR always_true:");
    println!("  test(&5): {} (always true)", combined_or_true.test(&5));
    println!("  test(&-3): {} (always true)", combined_or_true.test(&-3));

    // Combining with always_false (OR)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_or_false = is_positive.or(BoxPredicate::always_false());
    println!("\nis_positive OR always_false:");
    println!(
        "  test(&5): {} (equivalent to is_positive)",
        combined_or_false.test(&5)
    );
    println!(
        "  test(&-3): {} (equivalent to is_positive)",
        combined_or_false.test(&-3)
    );

    println!("\n=== Practical scenarios: Default pass/reject filters ===\n");

    // Scenario 1: Default pass-all filter
    let numbers = vec![1, 2, 3, 4, 5];
    let pass_all = BoxPredicate::<i32>::always_true();
    let filtered: Vec<_> = numbers.iter().copied().filter(pass_all.into_fn()).collect();
    println!("Default pass all elements: {:?} -> {:?}", numbers, filtered);

    // Scenario 2: Default reject-all filter
    let numbers = vec![1, 2, 3, 4, 5];
    let reject_all = BoxPredicate::<i32>::always_false();
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(reject_all.into_fn())
        .collect();
    println!(
        "Default reject all elements: {:?} -> {:?}",
        numbers, filtered
    );

    // Scenario 3: Configurable filter
    fn configurable_filter(enable_filter: bool) -> BoxPredicate<i32> {
        if enable_filter {
            BoxPredicate::new(|x: &i32| *x > 3)
        } else {
            BoxPredicate::always_true()
        }
    }

    let numbers = vec![1, 2, 3, 4, 5];

    let filter_enabled = configurable_filter(true);
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(filter_enabled.into_fn())
        .collect();
    println!("\nFilter enabled: {:?} -> {:?}", numbers, filtered);

    let filter_disabled = configurable_filter(false);
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(filter_disabled.into_fn())
        .collect();
    println!("Filter disabled: {:?} -> {:?}", numbers, filtered);
}

examples/mutator_once_conditional_demo.rs (lines 55-58)

fn main() {
    println!("=== MutatorOnce Conditional Execution Examples ===\n");

    // 1. Basic conditional execution - when condition is satisfied
    println!("1. Basic conditional execution - when condition is satisfied");
    let data = vec![1, 2, 3];
    let mutator = BoxMutatorOnce::new(move |x: &mut Vec<i32>| {
        println!("   Extending vector with data: {:?}", data);
        x.extend(data);
    });
    let conditional = mutator.when(|x: &Vec<i32>| {
        println!("   Checking condition: !x.is_empty()");
        !x.is_empty()
    });

    let mut target = vec![0];
    println!("   Initial: {:?}", target);
    conditional.mutate_once(&mut target);
    println!("   Result: {:?}\n", target);

    // 2. Conditional execution - when condition is not satisfied
    println!("2. Conditional execution - when condition is not satisfied");
    let data = vec![4, 5, 6];
    let mutator = BoxMutatorOnce::new(move |x: &mut Vec<i32>| {
        println!("   This should not be executed");
        x.extend(data);
    });
    let conditional = mutator.when(|x: &Vec<i32>| {
        println!("   Checking condition: x.len() > 10");
        x.len() > 10
    });

    let mut target = vec![0];
    println!("   Initial: {:?}", target);
    conditional.mutate_once(&mut target);
    println!("   Result: {:?} (unchanged)\n", target);

    // 3. Using BoxPredicate
    println!("3. Using BoxPredicate");
    let pred = BoxPredicate::new(|x: &Vec<i32>| {
        println!("   Predicate: checking if vector is not empty");
        !x.is_empty()
    });
    let data = vec![7, 8, 9];
    let mutator = BoxMutatorOnce::new(move |x: &mut Vec<i32>| {
        println!("   Adding data: {:?}", data);
        x.extend(data);
    });
    let conditional = mutator.when(pred);

    let mut target = vec![0];
    println!("   Initial: {:?}", target);
    conditional.mutate_once(&mut target);
    println!("   Result: {:?}\n", target);

    // 4. Using composed predicate
    println!("4. Using composed predicate");
    let pred = (|x: &Vec<i32>| {
        println!("   Condition 1: !x.is_empty()");
        !x.is_empty()
    })
    .and(|x: &Vec<i32>| {
        println!("   Condition 2: x.len() < 10");
        x.len() < 10
    });
    let data = vec![10, 11, 12];
    let mutator = BoxMutatorOnce::new(move |x: &mut Vec<i32>| {
        println!("   Adding data: {:?}", data);
        x.extend(data);
    });
    let conditional = mutator.when(pred);

    let mut target = vec![0];
    println!("   Initial: {:?}", target);
    conditional.mutate_once(&mut target);
    println!("   Result: {:?}\n", target);

    // 5. If-then-else with or_else - when branch
    println!("5. If-then-else with or_else - when branch");
    let data1 = vec![1, 2, 3];
    let data2 = vec![99];
    let mutator = BoxMutatorOnce::new(move |x: &mut Vec<i32>| {
        println!("   When branch: adding {:?}", data1);
        x.extend(data1);
    })
    .when(|x: &Vec<i32>| {
        println!("   Checking: !x.is_empty()");
        !x.is_empty()
    })
    .or_else(move |x: &mut Vec<i32>| {
        println!("   Else branch: adding {:?}", data2);
        x.extend(data2);
    });

    let mut target = vec![0];
    println!("   Initial: {:?}", target);
    mutator.mutate_once(&mut target);
    println!("   Result: {:?}\n", target);

    // 6. If-then-else with or_else - else branch
    println!("6. If-then-else with or_else - else branch");
    let data1 = vec![4, 5, 6];
    let data2 = vec![99];
    let mutator = BoxMutatorOnce::new(move |x: &mut Vec<i32>| {
        println!("   When branch: adding {:?}", data1);
        x.extend(data1);
    })
    .when(|x: &Vec<i32>| {
        println!("   Checking: x.is_empty()");
        x.is_empty()
    })
    .or_else(move |x: &mut Vec<i32>| {
        println!("   Else branch: adding {:?}", data2);
        x.extend(data2);
    });

    let mut target = vec![0];
    println!("   Initial: {:?}", target);
    mutator.mutate_once(&mut target);
    println!("   Result: {:?}\n", target);

    // 7. Conditional with integers
    println!("7. Conditional with integers");
    let mutator = BoxMutatorOnce::new(|x: &mut i32| {
        println!("   Multiplying by 2");
        *x *= 2;
    })
    .when(|x: &i32| {
        println!("   Checking: *x > 0");
        *x > 0
    });

    let mut positive = 5;
    println!("   Initial (positive): {}", positive);
    mutator.mutate_once(&mut positive);
    println!("   Result: {}\n", positive);

    // 8. Conditional with integers - not executed
    println!("8. Conditional with integers - not executed");
    let mutator = BoxMutatorOnce::new(|x: &mut i32| {
        println!("   This should not be executed");
        *x *= 2;
    })
    .when(|x: &i32| {
        println!("   Checking: *x > 0");
        *x > 0
    });

    let mut negative = -5;
    println!("   Initial (negative): {}", negative);
    mutator.mutate_once(&mut negative);
    println!("   Result: {} (unchanged)\n", negative);

    // 9. Chaining conditional mutators
    println!("9. Chaining conditional mutators");
    let data1 = vec![1, 2];
    let cond1 = BoxMutatorOnce::new(move |x: &mut Vec<i32>| {
        println!("   First mutator: adding {:?}", data1);
        x.extend(data1);
    })
    .when(|x: &Vec<i32>| {
        println!("   First condition: !x.is_empty()");
        !x.is_empty()
    });

    let data2 = vec![3, 4];
    let cond2 = BoxMutatorOnce::new(move |x: &mut Vec<i32>| {
        println!("   Second mutator: adding {:?}", data2);
        x.extend(data2);
    })
    .when(|x: &Vec<i32>| {
        println!("   Second condition: x.len() < 10");
        x.len() < 10
    });

    let chained = cond1.and_then(cond2);

    let mut target = vec![0];
    println!("   Initial: {:?}", target);
    chained.mutate_once(&mut target);
    println!("   Result: {:?}\n", target);

    // 10. Complex conditional chain
    println!("10. Complex conditional chain");
    let data1 = vec![1, 2];
    let data2 = vec![99];
    let data3 = vec![5, 6];

    let mutator = BoxMutatorOnce::new(move |x: &mut Vec<i32>| {
        println!("   When branch: adding {:?}", data1);
        x.extend(data1);
    })
    .when(|x: &Vec<i32>| {
        println!("   Checking: !x.is_empty()");
        !x.is_empty()
    })
    .or_else(move |x: &mut Vec<i32>| {
        println!("   Else branch: adding {:?}", data2);
        x.extend(data2);
    })
    .and_then(move |x: &mut Vec<i32>| {
        println!("   Final step: adding {:?}", data3);
        x.extend(data3);
    });

    let mut target = vec![0];
    println!("   Initial: {:?}", target);
    mutator.mutate_once(&mut target);
    println!("   Result: {:?}\n", target);

    // 11. Real-world scenario: data validation and processing
    println!("11. Real-world scenario: data validation and processing");

    struct DataProcessor {
        on_valid: Option<BoxMutatorOnce<Vec<String>>>,
        on_invalid: Option<BoxMutatorOnce<Vec<String>>>,
    }

    impl DataProcessor {
        fn new<V, I>(on_valid: V, on_invalid: I) -> Self
        where
            V: FnOnce(&mut Vec<String>) + 'static,
            I: FnOnce(&mut Vec<String>) + 'static,
        {
            Self {
                on_valid: Some(BoxMutatorOnce::new(on_valid)),
                on_invalid: Some(BoxMutatorOnce::new(on_invalid)),
            }
        }

        fn process(mut self, data: &mut Vec<String>) {
            let is_valid = !data.is_empty() && data.iter().all(|s| !s.is_empty());
            println!(
                "   Data validation: {}",
                if is_valid { "VALID" } else { "INVALID" }
            );

            if is_valid {
                if let Some(callback) = self.on_valid.take() {
                    callback.mutate_once(data);
                }
            } else if let Some(callback) = self.on_invalid.take() {
                callback.mutate_once(data);
            }
        }
    }

    let valid_suffix = vec!["processed".to_string()];
    let invalid_marker = vec!["[INVALID]".to_string()];

    let processor = DataProcessor::new(
        move |data| {
            println!("   Valid data callback: adding suffix");
            data.extend(valid_suffix);
        },
        move |data| {
            println!("   Invalid data callback: adding error marker");
            data.clear();
            data.extend(invalid_marker);
        },
    );

    let mut valid_data = vec!["item1".to_string(), "item2".to_string()];
    println!("   Processing valid data: {:?}", valid_data);
    processor.process(&mut valid_data);
    println!("   Result: {:?}\n", valid_data);

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

pub fn new_with_name<F>(name: &str, f: F) -> Self

where F: Fn(&T) -> bool + 'static,

Creates a named BoxPredicate from a closure.

Parameters

• name - The name for this predicate.
• f - The closure to wrap.

Returns

A new named BoxPredicate instance.

Examples found in repository

examples/predicate_demo.rs (line 87)

fn box_predicate_examples() {
    println!("--- 2. BoxPredicate Examples (Single Ownership) ---");

    // Basic BoxPredicate
    let pred = BoxPredicate::new(|x: &i32| *x > 0);
    println!("BoxPredicate test 5: {}", pred.test(&5));

    // Named predicate for better debugging
    let named_pred =
        BoxPredicate::new_with_name("is_positive_even", |x: &i32| *x > 0 && x % 2 == 0);
    println!("Predicate name: {:?}", named_pred.name());
    println!("Test 4: {}", named_pred.test(&4));

    // Method chaining - consumes self
    let positive = BoxPredicate::new_with_name("positive", |x: &i32| *x > 0);
    let even = BoxPredicate::new_with_name("even", |x: &i32| x % 2 == 0);
    let combined = positive.and(even);
    println!("Combined predicate name: {:?}", combined.name());
    println!("Test 4: {}", combined.test(&4));
}

examples/predicate_set_name_demo.rs (line 27)

fn demo_box_predicate() {
    println!("1. BoxPredicate Naming Functionality");

    // Create a predicate with name using new_with_name
    let pred1 = BoxPredicate::new_with_name("is_positive", |x: &i32| *x > 0);
    println!("   Created with new_with_name:");
    println!("     Name: {:?}", pred1.name());
    println!("     Test 5: {}", pred1.test(&5));

    // Set name for an existing predicate using set_name
    let mut pred2 = BoxPredicate::new(|x: &i32| x % 2 == 0);
    println!("\n   Created with new then set_name:");
    println!("     Initial name: {:?}", pred2.name());
    pred2.set_name("is_even");
    println!("     Name after setting: {:?}", pred2.name());
    println!("     Test 4: {}", pred2.test(&4));

    // Combined predicates automatically generate new names
    let pred3 = BoxPredicate::new_with_name("positive", |x: &i32| *x > 0);
    let pred4 = BoxPredicate::new_with_name("even", |x: &i32| x % 2 == 0);
    let combined = pred3.and(pred4);
    println!("\n   Combined predicate name:");
    println!("     Auto-generated name: {:?}", combined.name());
    println!("     Test 4: {}\n", combined.test(&4));
}

pub fn always_true() -> Self

Creates a predicate that always returns true.

Returns

A new BoxPredicate that always returns true.

Examples

use prism3_function::predicate::{Predicate, BoxPredicate};

let pred: BoxPredicate<i32> = BoxPredicate::always_true();
assert!(pred.test(&42));
assert!(pred.test(&-1));
assert!(pred.test(&0));

Examples found in repository

examples/always_predicate_demo.rs (line 15)

fn main() {
    println!("=== BoxPredicate always_true/always_false Demo ===\n");

    // BoxPredicate::always_true
    let always_true: BoxPredicate<i32> = BoxPredicate::always_true();
    println!("BoxPredicate::always_true():");
    println!("  test(&42): {}", always_true.test(&42));
    println!("  test(&-1): {}", always_true.test(&-1));
    println!("  test(&0): {}", always_true.test(&0));
    println!("  name: {:?}", always_true.name());

    // BoxPredicate::always_false
    let always_false: BoxPredicate<i32> = BoxPredicate::always_false();
    println!("\nBoxPredicate::always_false():");
    println!("  test(&42): {}", always_false.test(&42));
    println!("  test(&-1): {}", always_false.test(&-1));
    println!("  test(&0): {}", always_false.test(&0));
    println!("  name: {:?}", always_false.name());

    println!("\n=== RcPredicate always_true/always_false Demo ===\n");

    // RcPredicate::always_true
    let rc_always_true: RcPredicate<String> = RcPredicate::always_true();
    println!("RcPredicate::always_true():");
    println!(
        "  test(&\"hello\"): {}",
        rc_always_true.test(&"hello".to_string())
    );
    println!(
        "  test(&\"world\"): {}",
        rc_always_true.test(&"world".to_string())
    );
    println!("  name: {:?}", rc_always_true.name());

    // RcPredicate::always_false
    let rc_always_false: RcPredicate<String> = RcPredicate::always_false();
    println!("\nRcPredicate::always_false():");
    println!(
        "  test(&\"hello\"): {}",
        rc_always_false.test(&"hello".to_string())
    );
    println!(
        "  test(&\"world\"): {}",
        rc_always_false.test(&"world".to_string())
    );
    println!("  name: {:?}", rc_always_false.name());

    // Can be cloned and reused
    let rc_clone = rc_always_true.clone();
    println!("\nAfter cloning, still usable:");
    println!(
        "  Original: test(&\"test\"): {}",
        rc_always_true.test(&"test".to_string())
    );
    println!(
        "  Clone: test(&\"test\"): {}",
        rc_clone.test(&"test".to_string())
    );

    println!("\n=== ArcPredicate always_true/always_false Demo ===\n");

    // ArcPredicate::always_true
    let arc_always_true: ArcPredicate<i32> = ArcPredicate::always_true();
    println!("ArcPredicate::always_true():");
    println!("  test(&100): {}", arc_always_true.test(&100));
    println!("  test(&-100): {}", arc_always_true.test(&-100));
    println!("  name: {:?}", arc_always_true.name());

    // ArcPredicate::always_false
    let arc_always_false: ArcPredicate<i32> = ArcPredicate::always_false();
    println!("\nArcPredicate::always_false():");
    println!("  test(&100): {}", arc_always_false.test(&100));
    println!("  test(&-100): {}", arc_always_false.test(&-100));
    println!("  name: {:?}", arc_always_false.name());

    println!("\n=== Combining with other predicates ===\n");

    // Combining with always_true (AND)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_and_true = is_positive.and(BoxPredicate::always_true());
    println!("is_positive AND always_true:");
    println!(
        "  test(&5): {} (equivalent to is_positive)",
        combined_and_true.test(&5)
    );
    println!(
        "  test(&-3): {} (equivalent to is_positive)",
        combined_and_true.test(&-3)
    );

    // Combining with always_false (AND)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_and_false = is_positive.and(BoxPredicate::always_false());
    println!("\nis_positive AND always_false:");
    println!("  test(&5): {} (always false)", combined_and_false.test(&5));
    println!(
        "  test(&-3): {} (always false)",
        combined_and_false.test(&-3)
    );

    // Combining with always_true (OR)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_or_true = is_positive.or(BoxPredicate::always_true());
    println!("\nis_positive OR always_true:");
    println!("  test(&5): {} (always true)", combined_or_true.test(&5));
    println!("  test(&-3): {} (always true)", combined_or_true.test(&-3));

    // Combining with always_false (OR)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_or_false = is_positive.or(BoxPredicate::always_false());
    println!("\nis_positive OR always_false:");
    println!(
        "  test(&5): {} (equivalent to is_positive)",
        combined_or_false.test(&5)
    );
    println!(
        "  test(&-3): {} (equivalent to is_positive)",
        combined_or_false.test(&-3)
    );

    println!("\n=== Practical scenarios: Default pass/reject filters ===\n");

    // Scenario 1: Default pass-all filter
    let numbers = vec![1, 2, 3, 4, 5];
    let pass_all = BoxPredicate::<i32>::always_true();
    let filtered: Vec<_> = numbers.iter().copied().filter(pass_all.into_fn()).collect();
    println!("Default pass all elements: {:?} -> {:?}", numbers, filtered);

    // Scenario 2: Default reject-all filter
    let numbers = vec![1, 2, 3, 4, 5];
    let reject_all = BoxPredicate::<i32>::always_false();
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(reject_all.into_fn())
        .collect();
    println!(
        "Default reject all elements: {:?} -> {:?}",
        numbers, filtered
    );

    // Scenario 3: Configurable filter
    fn configurable_filter(enable_filter: bool) -> BoxPredicate<i32> {
        if enable_filter {
            BoxPredicate::new(|x: &i32| *x > 3)
        } else {
            BoxPredicate::always_true()
        }
    }

    let numbers = vec![1, 2, 3, 4, 5];

    let filter_enabled = configurable_filter(true);
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(filter_enabled.into_fn())
        .collect();
    println!("\nFilter enabled: {:?} -> {:?}", numbers, filtered);

    let filter_disabled = configurable_filter(false);
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(filter_disabled.into_fn())
        .collect();
    println!("Filter disabled: {:?} -> {:?}", numbers, filtered);
}

pub fn always_false() -> Self

Creates a predicate that always returns false.

Returns

A new BoxPredicate that always returns false.

Examples

use prism3_function::predicate::{Predicate, BoxPredicate};

let pred: BoxPredicate<i32> = BoxPredicate::always_false();
assert!(!pred.test(&42));
assert!(!pred.test(&-1));
assert!(!pred.test(&0));

Examples found in repository

examples/always_predicate_demo.rs (line 23)

fn main() {
    println!("=== BoxPredicate always_true/always_false Demo ===\n");

    // BoxPredicate::always_true
    let always_true: BoxPredicate<i32> = BoxPredicate::always_true();
    println!("BoxPredicate::always_true():");
    println!("  test(&42): {}", always_true.test(&42));
    println!("  test(&-1): {}", always_true.test(&-1));
    println!("  test(&0): {}", always_true.test(&0));
    println!("  name: {:?}", always_true.name());

    // BoxPredicate::always_false
    let always_false: BoxPredicate<i32> = BoxPredicate::always_false();
    println!("\nBoxPredicate::always_false():");
    println!("  test(&42): {}", always_false.test(&42));
    println!("  test(&-1): {}", always_false.test(&-1));
    println!("  test(&0): {}", always_false.test(&0));
    println!("  name: {:?}", always_false.name());

    println!("\n=== RcPredicate always_true/always_false Demo ===\n");

    // RcPredicate::always_true
    let rc_always_true: RcPredicate<String> = RcPredicate::always_true();
    println!("RcPredicate::always_true():");
    println!(
        "  test(&\"hello\"): {}",
        rc_always_true.test(&"hello".to_string())
    );
    println!(
        "  test(&\"world\"): {}",
        rc_always_true.test(&"world".to_string())
    );
    println!("  name: {:?}", rc_always_true.name());

    // RcPredicate::always_false
    let rc_always_false: RcPredicate<String> = RcPredicate::always_false();
    println!("\nRcPredicate::always_false():");
    println!(
        "  test(&\"hello\"): {}",
        rc_always_false.test(&"hello".to_string())
    );
    println!(
        "  test(&\"world\"): {}",
        rc_always_false.test(&"world".to_string())
    );
    println!("  name: {:?}", rc_always_false.name());

    // Can be cloned and reused
    let rc_clone = rc_always_true.clone();
    println!("\nAfter cloning, still usable:");
    println!(
        "  Original: test(&\"test\"): {}",
        rc_always_true.test(&"test".to_string())
    );
    println!(
        "  Clone: test(&\"test\"): {}",
        rc_clone.test(&"test".to_string())
    );

    println!("\n=== ArcPredicate always_true/always_false Demo ===\n");

    // ArcPredicate::always_true
    let arc_always_true: ArcPredicate<i32> = ArcPredicate::always_true();
    println!("ArcPredicate::always_true():");
    println!("  test(&100): {}", arc_always_true.test(&100));
    println!("  test(&-100): {}", arc_always_true.test(&-100));
    println!("  name: {:?}", arc_always_true.name());

    // ArcPredicate::always_false
    let arc_always_false: ArcPredicate<i32> = ArcPredicate::always_false();
    println!("\nArcPredicate::always_false():");
    println!("  test(&100): {}", arc_always_false.test(&100));
    println!("  test(&-100): {}", arc_always_false.test(&-100));
    println!("  name: {:?}", arc_always_false.name());

    println!("\n=== Combining with other predicates ===\n");

    // Combining with always_true (AND)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_and_true = is_positive.and(BoxPredicate::always_true());
    println!("is_positive AND always_true:");
    println!(
        "  test(&5): {} (equivalent to is_positive)",
        combined_and_true.test(&5)
    );
    println!(
        "  test(&-3): {} (equivalent to is_positive)",
        combined_and_true.test(&-3)
    );

    // Combining with always_false (AND)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_and_false = is_positive.and(BoxPredicate::always_false());
    println!("\nis_positive AND always_false:");
    println!("  test(&5): {} (always false)", combined_and_false.test(&5));
    println!(
        "  test(&-3): {} (always false)",
        combined_and_false.test(&-3)
    );

    // Combining with always_true (OR)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_or_true = is_positive.or(BoxPredicate::always_true());
    println!("\nis_positive OR always_true:");
    println!("  test(&5): {} (always true)", combined_or_true.test(&5));
    println!("  test(&-3): {} (always true)", combined_or_true.test(&-3));

    // Combining with always_false (OR)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_or_false = is_positive.or(BoxPredicate::always_false());
    println!("\nis_positive OR always_false:");
    println!(
        "  test(&5): {} (equivalent to is_positive)",
        combined_or_false.test(&5)
    );
    println!(
        "  test(&-3): {} (equivalent to is_positive)",
        combined_or_false.test(&-3)
    );

    println!("\n=== Practical scenarios: Default pass/reject filters ===\n");

    // Scenario 1: Default pass-all filter
    let numbers = vec![1, 2, 3, 4, 5];
    let pass_all = BoxPredicate::<i32>::always_true();
    let filtered: Vec<_> = numbers.iter().copied().filter(pass_all.into_fn()).collect();
    println!("Default pass all elements: {:?} -> {:?}", numbers, filtered);

    // Scenario 2: Default reject-all filter
    let numbers = vec![1, 2, 3, 4, 5];
    let reject_all = BoxPredicate::<i32>::always_false();
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(reject_all.into_fn())
        .collect();
    println!(
        "Default reject all elements: {:?} -> {:?}",
        numbers, filtered
    );

    // Scenario 3: Configurable filter
    fn configurable_filter(enable_filter: bool) -> BoxPredicate<i32> {
        if enable_filter {
            BoxPredicate::new(|x: &i32| *x > 3)
        } else {
            BoxPredicate::always_true()
        }
    }

    let numbers = vec![1, 2, 3, 4, 5];

    let filter_enabled = configurable_filter(true);
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(filter_enabled.into_fn())
        .collect();
    println!("\nFilter enabled: {:?} -> {:?}", numbers, filtered);

    let filter_disabled = configurable_filter(false);
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(filter_disabled.into_fn())
        .collect();
    println!("Filter disabled: {:?} -> {:?}", numbers, filtered);
}

pub fn name(&self) -> Option<&str>

Returns the name of this predicate, if set.

Returns

An Option containing the predicate’s name.

Examples found in repository

examples/predicate_demo.rs (line 88)

fn box_predicate_examples() {
    println!("--- 2. BoxPredicate Examples (Single Ownership) ---");

    // Basic BoxPredicate
    let pred = BoxPredicate::new(|x: &i32| *x > 0);
    println!("BoxPredicate test 5: {}", pred.test(&5));

    // Named predicate for better debugging
    let named_pred =
        BoxPredicate::new_with_name("is_positive_even", |x: &i32| *x > 0 && x % 2 == 0);
    println!("Predicate name: {:?}", named_pred.name());
    println!("Test 4: {}", named_pred.test(&4));

    // Method chaining - consumes self
    let positive = BoxPredicate::new_with_name("positive", |x: &i32| *x > 0);
    let even = BoxPredicate::new_with_name("even", |x: &i32| x % 2 == 0);
    let combined = positive.and(even);
    println!("Combined predicate name: {:?}", combined.name());
    println!("Test 4: {}", combined.test(&4));
}

examples/predicate_set_name_demo.rs (line 29)

fn demo_box_predicate() {
    println!("1. BoxPredicate Naming Functionality");

    // Create a predicate with name using new_with_name
    let pred1 = BoxPredicate::new_with_name("is_positive", |x: &i32| *x > 0);
    println!("   Created with new_with_name:");
    println!("     Name: {:?}", pred1.name());
    println!("     Test 5: {}", pred1.test(&5));

    // Set name for an existing predicate using set_name
    let mut pred2 = BoxPredicate::new(|x: &i32| x % 2 == 0);
    println!("\n   Created with new then set_name:");
    println!("     Initial name: {:?}", pred2.name());
    pred2.set_name("is_even");
    println!("     Name after setting: {:?}", pred2.name());
    println!("     Test 4: {}", pred2.test(&4));

    // Combined predicates automatically generate new names
    let pred3 = BoxPredicate::new_with_name("positive", |x: &i32| *x > 0);
    let pred4 = BoxPredicate::new_with_name("even", |x: &i32| x % 2 == 0);
    let combined = pred3.and(pred4);
    println!("\n   Combined predicate name:");
    println!("     Auto-generated name: {:?}", combined.name());
    println!("     Test 4: {}\n", combined.test(&4));
}

examples/always_predicate_demo.rs (line 20)

fn main() {
    println!("=== BoxPredicate always_true/always_false Demo ===\n");

    // BoxPredicate::always_true
    let always_true: BoxPredicate<i32> = BoxPredicate::always_true();
    println!("BoxPredicate::always_true():");
    println!("  test(&42): {}", always_true.test(&42));
    println!("  test(&-1): {}", always_true.test(&-1));
    println!("  test(&0): {}", always_true.test(&0));
    println!("  name: {:?}", always_true.name());

    // BoxPredicate::always_false
    let always_false: BoxPredicate<i32> = BoxPredicate::always_false();
    println!("\nBoxPredicate::always_false():");
    println!("  test(&42): {}", always_false.test(&42));
    println!("  test(&-1): {}", always_false.test(&-1));
    println!("  test(&0): {}", always_false.test(&0));
    println!("  name: {:?}", always_false.name());

    println!("\n=== RcPredicate always_true/always_false Demo ===\n");

    // RcPredicate::always_true
    let rc_always_true: RcPredicate<String> = RcPredicate::always_true();
    println!("RcPredicate::always_true():");
    println!(
        "  test(&\"hello\"): {}",
        rc_always_true.test(&"hello".to_string())
    );
    println!(
        "  test(&\"world\"): {}",
        rc_always_true.test(&"world".to_string())
    );
    println!("  name: {:?}", rc_always_true.name());

    // RcPredicate::always_false
    let rc_always_false: RcPredicate<String> = RcPredicate::always_false();
    println!("\nRcPredicate::always_false():");
    println!(
        "  test(&\"hello\"): {}",
        rc_always_false.test(&"hello".to_string())
    );
    println!(
        "  test(&\"world\"): {}",
        rc_always_false.test(&"world".to_string())
    );
    println!("  name: {:?}", rc_always_false.name());

    // Can be cloned and reused
    let rc_clone = rc_always_true.clone();
    println!("\nAfter cloning, still usable:");
    println!(
        "  Original: test(&\"test\"): {}",
        rc_always_true.test(&"test".to_string())
    );
    println!(
        "  Clone: test(&\"test\"): {}",
        rc_clone.test(&"test".to_string())
    );

    println!("\n=== ArcPredicate always_true/always_false Demo ===\n");

    // ArcPredicate::always_true
    let arc_always_true: ArcPredicate<i32> = ArcPredicate::always_true();
    println!("ArcPredicate::always_true():");
    println!("  test(&100): {}", arc_always_true.test(&100));
    println!("  test(&-100): {}", arc_always_true.test(&-100));
    println!("  name: {:?}", arc_always_true.name());

    // ArcPredicate::always_false
    let arc_always_false: ArcPredicate<i32> = ArcPredicate::always_false();
    println!("\nArcPredicate::always_false():");
    println!("  test(&100): {}", arc_always_false.test(&100));
    println!("  test(&-100): {}", arc_always_false.test(&-100));
    println!("  name: {:?}", arc_always_false.name());

    println!("\n=== Combining with other predicates ===\n");

    // Combining with always_true (AND)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_and_true = is_positive.and(BoxPredicate::always_true());
    println!("is_positive AND always_true:");
    println!(
        "  test(&5): {} (equivalent to is_positive)",
        combined_and_true.test(&5)
    );
    println!(
        "  test(&-3): {} (equivalent to is_positive)",
        combined_and_true.test(&-3)
    );

    // Combining with always_false (AND)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_and_false = is_positive.and(BoxPredicate::always_false());
    println!("\nis_positive AND always_false:");
    println!("  test(&5): {} (always false)", combined_and_false.test(&5));
    println!(
        "  test(&-3): {} (always false)",
        combined_and_false.test(&-3)
    );

    // Combining with always_true (OR)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_or_true = is_positive.or(BoxPredicate::always_true());
    println!("\nis_positive OR always_true:");
    println!("  test(&5): {} (always true)", combined_or_true.test(&5));
    println!("  test(&-3): {} (always true)", combined_or_true.test(&-3));

    // Combining with always_false (OR)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_or_false = is_positive.or(BoxPredicate::always_false());
    println!("\nis_positive OR always_false:");
    println!(
        "  test(&5): {} (equivalent to is_positive)",
        combined_or_false.test(&5)
    );
    println!(
        "  test(&-3): {} (equivalent to is_positive)",
        combined_or_false.test(&-3)
    );

    println!("\n=== Practical scenarios: Default pass/reject filters ===\n");

    // Scenario 1: Default pass-all filter
    let numbers = vec![1, 2, 3, 4, 5];
    let pass_all = BoxPredicate::<i32>::always_true();
    let filtered: Vec<_> = numbers.iter().copied().filter(pass_all.into_fn()).collect();
    println!("Default pass all elements: {:?} -> {:?}", numbers, filtered);

    // Scenario 2: Default reject-all filter
    let numbers = vec![1, 2, 3, 4, 5];
    let reject_all = BoxPredicate::<i32>::always_false();
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(reject_all.into_fn())
        .collect();
    println!(
        "Default reject all elements: {:?} -> {:?}",
        numbers, filtered
    );

    // Scenario 3: Configurable filter
    fn configurable_filter(enable_filter: bool) -> BoxPredicate<i32> {
        if enable_filter {
            BoxPredicate::new(|x: &i32| *x > 3)
        } else {
            BoxPredicate::always_true()
        }
    }

    let numbers = vec![1, 2, 3, 4, 5];

    let filter_enabled = configurable_filter(true);
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(filter_enabled.into_fn())
        .collect();
    println!("\nFilter enabled: {:?} -> {:?}", numbers, filtered);

    let filter_disabled = configurable_filter(false);
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(filter_disabled.into_fn())
        .collect();
    println!("Filter disabled: {:?} -> {:?}", numbers, filtered);
}

pub fn set_name(&mut self, name: &str)

Sets the name of this predicate.

Parameters

• name - The new name for this predicate.

Examples found in repository

examples/predicate_set_name_demo.rs (line 36)

fn demo_box_predicate() {
    println!("1. BoxPredicate Naming Functionality");

    // Create a predicate with name using new_with_name
    let pred1 = BoxPredicate::new_with_name("is_positive", |x: &i32| *x > 0);
    println!("   Created with new_with_name:");
    println!("     Name: {:?}", pred1.name());
    println!("     Test 5: {}", pred1.test(&5));

    // Set name for an existing predicate using set_name
    let mut pred2 = BoxPredicate::new(|x: &i32| x % 2 == 0);
    println!("\n   Created with new then set_name:");
    println!("     Initial name: {:?}", pred2.name());
    pred2.set_name("is_even");
    println!("     Name after setting: {:?}", pred2.name());
    println!("     Test 4: {}", pred2.test(&4));

    // Combined predicates automatically generate new names
    let pred3 = BoxPredicate::new_with_name("positive", |x: &i32| *x > 0);
    let pred4 = BoxPredicate::new_with_name("even", |x: &i32| x % 2 == 0);
    let combined = pred3.and(pred4);
    println!("\n   Combined predicate name:");
    println!("     Auto-generated name: {:?}", combined.name());
    println!("     Test 4: {}\n", combined.test(&4));
}

pub fn and<P>(self, other: P) -> BoxPredicate<T>

where P: Predicate<T> + 'static,

Returns a predicate that represents the logical AND of this predicate and another.

This method consumes self due to single-ownership semantics.

Parameters

• other - The other predicate to combine with. 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
  • Another BoxPredicate<T>
  • An RcPredicate<T>
  • An ArcPredicate<T>
  • Any type implementing Predicate<T>

Returns

A new BoxPredicate representing the logical AND.

Examples

Combining with closures

use prism3_function::predicate::{Predicate, BoxPredicate};

let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
let is_even = |x: &i32| x % 2 == 0;

// Note: is_positive is moved here, so it's no longer usable
let combined = is_positive.and(is_even);
assert!(combined.test(&4));   // positive and even
assert!(!combined.test(&3));  // positive but odd
assert!(!combined.test(&-2)); // even but negative
// is_positive.test(&5); // This would not compile - is_positive was moved

Combining with function pointers

use prism3_function::predicate::{Predicate, BoxPredicate};

fn is_even(x: &i32) -> bool { x % 2 == 0 }

let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
let combined = is_positive.and(is_even);

assert!(combined.test(&4));
assert!(!combined.test(&3));

Combining with other BoxPredicate

use prism3_function::predicate::{Predicate, BoxPredicate};

let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
let is_even = BoxPredicate::new(|x: &i32| x % 2 == 0);

let combined = is_positive.and(is_even);
assert!(combined.test(&4));
assert!(!combined.test(&3));

Chained composition

use prism3_function::predicate::{Predicate, BoxPredicate};

let pred = BoxPredicate::new(|x: &i32| *x > 0)
    .and(|x: &i32| x % 2 == 0)
    .and(|x: &i32| *x < 100);

assert!(pred.test(&42));  // positive, even, less than 100
assert!(!pred.test(&101)); // does not satisfy less than 100

Preserving original predicates with clone

use prism3_function::predicate::{Predicate, BoxPredicate};

let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
let is_even = BoxPredicate::new(|x: &i32| x % 2 == 0);

// Clone the predicates to preserve them for later use
let combined = is_positive.clone().and(is_even.clone());
assert!(combined.test(&4));

// Original predicates are still usable
assert!(is_positive.test(&5));
assert!(is_even.test(&6));

Examples found in repository

examples/predicate_demo.rs (line 94)

fn box_predicate_examples() {
    println!("--- 2. BoxPredicate Examples (Single Ownership) ---");

    // Basic BoxPredicate
    let pred = BoxPredicate::new(|x: &i32| *x > 0);
    println!("BoxPredicate test 5: {}", pred.test(&5));

    // Named predicate for better debugging
    let named_pred =
        BoxPredicate::new_with_name("is_positive_even", |x: &i32| *x > 0 && x % 2 == 0);
    println!("Predicate name: {:?}", named_pred.name());
    println!("Test 4: {}", named_pred.test(&4));

    // Method chaining - consumes self
    let positive = BoxPredicate::new_with_name("positive", |x: &i32| *x > 0);
    let even = BoxPredicate::new_with_name("even", |x: &i32| x % 2 == 0);
    let combined = positive.and(even);
    println!("Combined predicate name: {:?}", combined.name());
    println!("Test 4: {}", combined.test(&4));
}

examples/predicate_set_name_demo.rs (line 43)

fn demo_box_predicate() {
    println!("1. BoxPredicate Naming Functionality");

    // Create a predicate with name using new_with_name
    let pred1 = BoxPredicate::new_with_name("is_positive", |x: &i32| *x > 0);
    println!("   Created with new_with_name:");
    println!("     Name: {:?}", pred1.name());
    println!("     Test 5: {}", pred1.test(&5));

    // Set name for an existing predicate using set_name
    let mut pred2 = BoxPredicate::new(|x: &i32| x % 2 == 0);
    println!("\n   Created with new then set_name:");
    println!("     Initial name: {:?}", pred2.name());
    pred2.set_name("is_even");
    println!("     Name after setting: {:?}", pred2.name());
    println!("     Test 4: {}", pred2.test(&4));

    // Combined predicates automatically generate new names
    let pred3 = BoxPredicate::new_with_name("positive", |x: &i32| *x > 0);
    let pred4 = BoxPredicate::new_with_name("even", |x: &i32| x % 2 == 0);
    let combined = pred3.and(pred4);
    println!("\n   Combined predicate name:");
    println!("     Auto-generated name: {:?}", combined.name());
    println!("     Test 4: {}\n", combined.test(&4));
}

examples/always_predicate_demo.rs (line 90)

fn main() {
    println!("=== BoxPredicate always_true/always_false Demo ===\n");

    // BoxPredicate::always_true
    let always_true: BoxPredicate<i32> = BoxPredicate::always_true();
    println!("BoxPredicate::always_true():");
    println!("  test(&42): {}", always_true.test(&42));
    println!("  test(&-1): {}", always_true.test(&-1));
    println!("  test(&0): {}", always_true.test(&0));
    println!("  name: {:?}", always_true.name());

    // BoxPredicate::always_false
    let always_false: BoxPredicate<i32> = BoxPredicate::always_false();
    println!("\nBoxPredicate::always_false():");
    println!("  test(&42): {}", always_false.test(&42));
    println!("  test(&-1): {}", always_false.test(&-1));
    println!("  test(&0): {}", always_false.test(&0));
    println!("  name: {:?}", always_false.name());

    println!("\n=== RcPredicate always_true/always_false Demo ===\n");

    // RcPredicate::always_true
    let rc_always_true: RcPredicate<String> = RcPredicate::always_true();
    println!("RcPredicate::always_true():");
    println!(
        "  test(&\"hello\"): {}",
        rc_always_true.test(&"hello".to_string())
    );
    println!(
        "  test(&\"world\"): {}",
        rc_always_true.test(&"world".to_string())
    );
    println!("  name: {:?}", rc_always_true.name());

    // RcPredicate::always_false
    let rc_always_false: RcPredicate<String> = RcPredicate::always_false();
    println!("\nRcPredicate::always_false():");
    println!(
        "  test(&\"hello\"): {}",
        rc_always_false.test(&"hello".to_string())
    );
    println!(
        "  test(&\"world\"): {}",
        rc_always_false.test(&"world".to_string())
    );
    println!("  name: {:?}", rc_always_false.name());

    // Can be cloned and reused
    let rc_clone = rc_always_true.clone();
    println!("\nAfter cloning, still usable:");
    println!(
        "  Original: test(&\"test\"): {}",
        rc_always_true.test(&"test".to_string())
    );
    println!(
        "  Clone: test(&\"test\"): {}",
        rc_clone.test(&"test".to_string())
    );

    println!("\n=== ArcPredicate always_true/always_false Demo ===\n");

    // ArcPredicate::always_true
    let arc_always_true: ArcPredicate<i32> = ArcPredicate::always_true();
    println!("ArcPredicate::always_true():");
    println!("  test(&100): {}", arc_always_true.test(&100));
    println!("  test(&-100): {}", arc_always_true.test(&-100));
    println!("  name: {:?}", arc_always_true.name());

    // ArcPredicate::always_false
    let arc_always_false: ArcPredicate<i32> = ArcPredicate::always_false();
    println!("\nArcPredicate::always_false():");
    println!("  test(&100): {}", arc_always_false.test(&100));
    println!("  test(&-100): {}", arc_always_false.test(&-100));
    println!("  name: {:?}", arc_always_false.name());

    println!("\n=== Combining with other predicates ===\n");

    // Combining with always_true (AND)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_and_true = is_positive.and(BoxPredicate::always_true());
    println!("is_positive AND always_true:");
    println!(
        "  test(&5): {} (equivalent to is_positive)",
        combined_and_true.test(&5)
    );
    println!(
        "  test(&-3): {} (equivalent to is_positive)",
        combined_and_true.test(&-3)
    );

    // Combining with always_false (AND)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_and_false = is_positive.and(BoxPredicate::always_false());
    println!("\nis_positive AND always_false:");
    println!("  test(&5): {} (always false)", combined_and_false.test(&5));
    println!(
        "  test(&-3): {} (always false)",
        combined_and_false.test(&-3)
    );

    // Combining with always_true (OR)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_or_true = is_positive.or(BoxPredicate::always_true());
    println!("\nis_positive OR always_true:");
    println!("  test(&5): {} (always true)", combined_or_true.test(&5));
    println!("  test(&-3): {} (always true)", combined_or_true.test(&-3));

    // Combining with always_false (OR)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_or_false = is_positive.or(BoxPredicate::always_false());
    println!("\nis_positive OR always_false:");
    println!(
        "  test(&5): {} (equivalent to is_positive)",
        combined_or_false.test(&5)
    );
    println!(
        "  test(&-3): {} (equivalent to is_positive)",
        combined_or_false.test(&-3)
    );

    println!("\n=== Practical scenarios: Default pass/reject filters ===\n");

    // Scenario 1: Default pass-all filter
    let numbers = vec![1, 2, 3, 4, 5];
    let pass_all = BoxPredicate::<i32>::always_true();
    let filtered: Vec<_> = numbers.iter().copied().filter(pass_all.into_fn()).collect();
    println!("Default pass all elements: {:?} -> {:?}", numbers, filtered);

    // Scenario 2: Default reject-all filter
    let numbers = vec![1, 2, 3, 4, 5];
    let reject_all = BoxPredicate::<i32>::always_false();
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(reject_all.into_fn())
        .collect();
    println!(
        "Default reject all elements: {:?} -> {:?}",
        numbers, filtered
    );

    // Scenario 3: Configurable filter
    fn configurable_filter(enable_filter: bool) -> BoxPredicate<i32> {
        if enable_filter {
            BoxPredicate::new(|x: &i32| *x > 3)
        } else {
            BoxPredicate::always_true()
        }
    }

    let numbers = vec![1, 2, 3, 4, 5];

    let filter_enabled = configurable_filter(true);
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(filter_enabled.into_fn())
        .collect();
    println!("\nFilter enabled: {:?} -> {:?}", numbers, filtered);

    let filter_disabled = configurable_filter(false);
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(filter_disabled.into_fn())
        .collect();
    println!("Filter disabled: {:?} -> {:?}", numbers, filtered);
}

pub fn or<P>(self, other: P) -> BoxPredicate<T>

where P: Predicate<T> + 'static,

Returns a predicate that represents the logical OR of this predicate and another.

This method consumes self due to single-ownership semantics.

Parameters

• other - The other predicate to combine with. 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
  • Another BoxPredicate<T>
  • An RcPredicate<T>
  • An ArcPredicate<T>
  • Any type implementing Predicate<T>

Returns

A new BoxPredicate representing the logical OR.

Examples

Combining with closures

use prism3_function::predicate::{Predicate, BoxPredicate};

let is_negative = BoxPredicate::new(|x: &i32| *x < 0);
let is_large = |x: &i32| *x > 100;

// Note: is_negative is moved here, so it's no longer usable
let combined = is_negative.or(is_large);
assert!(combined.test(&-5));  // negative
assert!(combined.test(&150)); // greater than 100
assert!(!combined.test(&50)); // neither negative nor greater than 100
// is_negative.test(&-10); // This would not compile - is_negative was moved

Combining with function pointers

use prism3_function::predicate::{Predicate, BoxPredicate};

fn is_large(x: &i32) -> bool { *x > 100 }

let is_negative = BoxPredicate::new(|x: &i32| *x < 0);
let combined = is_negative.or(is_large);

assert!(combined.test(&-5));
assert!(combined.test(&150));

Combining with other BoxPredicate

use prism3_function::predicate::{Predicate, BoxPredicate};

let is_negative = BoxPredicate::new(|x: &i32| *x < 0);
let is_large = BoxPredicate::new(|x: &i32| *x > 100);

let combined = is_negative.or(is_large);
assert!(combined.test(&-5));
assert!(combined.test(&150));

Preserving original predicates with clone

use prism3_function::predicate::{Predicate, BoxPredicate};

let is_negative = BoxPredicate::new(|x: &i32| *x < 0);
let is_large = BoxPredicate::new(|x: &i32| *x > 100);

// Clone the predicates to preserve them for later use
let combined = is_negative.clone().or(is_large.clone());
assert!(combined.test(&-5));
assert!(combined.test(&150));

// Original predicates are still usable
assert!(is_negative.test(&-10));
assert!(is_large.test(&200));

Examples found in repository

examples/always_predicate_demo.rs (line 113)

fn main() {
    println!("=== BoxPredicate always_true/always_false Demo ===\n");

    // BoxPredicate::always_true
    let always_true: BoxPredicate<i32> = BoxPredicate::always_true();
    println!("BoxPredicate::always_true():");
    println!("  test(&42): {}", always_true.test(&42));
    println!("  test(&-1): {}", always_true.test(&-1));
    println!("  test(&0): {}", always_true.test(&0));
    println!("  name: {:?}", always_true.name());

    // BoxPredicate::always_false
    let always_false: BoxPredicate<i32> = BoxPredicate::always_false();
    println!("\nBoxPredicate::always_false():");
    println!("  test(&42): {}", always_false.test(&42));
    println!("  test(&-1): {}", always_false.test(&-1));
    println!("  test(&0): {}", always_false.test(&0));
    println!("  name: {:?}", always_false.name());

    println!("\n=== RcPredicate always_true/always_false Demo ===\n");

    // RcPredicate::always_true
    let rc_always_true: RcPredicate<String> = RcPredicate::always_true();
    println!("RcPredicate::always_true():");
    println!(
        "  test(&\"hello\"): {}",
        rc_always_true.test(&"hello".to_string())
    );
    println!(
        "  test(&\"world\"): {}",
        rc_always_true.test(&"world".to_string())
    );
    println!("  name: {:?}", rc_always_true.name());

    // RcPredicate::always_false
    let rc_always_false: RcPredicate<String> = RcPredicate::always_false();
    println!("\nRcPredicate::always_false():");
    println!(
        "  test(&\"hello\"): {}",
        rc_always_false.test(&"hello".to_string())
    );
    println!(
        "  test(&\"world\"): {}",
        rc_always_false.test(&"world".to_string())
    );
    println!("  name: {:?}", rc_always_false.name());

    // Can be cloned and reused
    let rc_clone = rc_always_true.clone();
    println!("\nAfter cloning, still usable:");
    println!(
        "  Original: test(&\"test\"): {}",
        rc_always_true.test(&"test".to_string())
    );
    println!(
        "  Clone: test(&\"test\"): {}",
        rc_clone.test(&"test".to_string())
    );

    println!("\n=== ArcPredicate always_true/always_false Demo ===\n");

    // ArcPredicate::always_true
    let arc_always_true: ArcPredicate<i32> = ArcPredicate::always_true();
    println!("ArcPredicate::always_true():");
    println!("  test(&100): {}", arc_always_true.test(&100));
    println!("  test(&-100): {}", arc_always_true.test(&-100));
    println!("  name: {:?}", arc_always_true.name());

    // ArcPredicate::always_false
    let arc_always_false: ArcPredicate<i32> = ArcPredicate::always_false();
    println!("\nArcPredicate::always_false():");
    println!("  test(&100): {}", arc_always_false.test(&100));
    println!("  test(&-100): {}", arc_always_false.test(&-100));
    println!("  name: {:?}", arc_always_false.name());

    println!("\n=== Combining with other predicates ===\n");

    // Combining with always_true (AND)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_and_true = is_positive.and(BoxPredicate::always_true());
    println!("is_positive AND always_true:");
    println!(
        "  test(&5): {} (equivalent to is_positive)",
        combined_and_true.test(&5)
    );
    println!(
        "  test(&-3): {} (equivalent to is_positive)",
        combined_and_true.test(&-3)
    );

    // Combining with always_false (AND)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_and_false = is_positive.and(BoxPredicate::always_false());
    println!("\nis_positive AND always_false:");
    println!("  test(&5): {} (always false)", combined_and_false.test(&5));
    println!(
        "  test(&-3): {} (always false)",
        combined_and_false.test(&-3)
    );

    // Combining with always_true (OR)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_or_true = is_positive.or(BoxPredicate::always_true());
    println!("\nis_positive OR always_true:");
    println!("  test(&5): {} (always true)", combined_or_true.test(&5));
    println!("  test(&-3): {} (always true)", combined_or_true.test(&-3));

    // Combining with always_false (OR)
    let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
    let combined_or_false = is_positive.or(BoxPredicate::always_false());
    println!("\nis_positive OR always_false:");
    println!(
        "  test(&5): {} (equivalent to is_positive)",
        combined_or_false.test(&5)
    );
    println!(
        "  test(&-3): {} (equivalent to is_positive)",
        combined_or_false.test(&-3)
    );

    println!("\n=== Practical scenarios: Default pass/reject filters ===\n");

    // Scenario 1: Default pass-all filter
    let numbers = vec![1, 2, 3, 4, 5];
    let pass_all = BoxPredicate::<i32>::always_true();
    let filtered: Vec<_> = numbers.iter().copied().filter(pass_all.into_fn()).collect();
    println!("Default pass all elements: {:?} -> {:?}", numbers, filtered);

    // Scenario 2: Default reject-all filter
    let numbers = vec![1, 2, 3, 4, 5];
    let reject_all = BoxPredicate::<i32>::always_false();
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(reject_all.into_fn())
        .collect();
    println!(
        "Default reject all elements: {:?} -> {:?}",
        numbers, filtered
    );

    // Scenario 3: Configurable filter
    fn configurable_filter(enable_filter: bool) -> BoxPredicate<i32> {
        if enable_filter {
            BoxPredicate::new(|x: &i32| *x > 3)
        } else {
            BoxPredicate::always_true()
        }
    }

    let numbers = vec![1, 2, 3, 4, 5];

    let filter_enabled = configurable_filter(true);
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(filter_enabled.into_fn())
        .collect();
    println!("\nFilter enabled: {:?} -> {:?}", numbers, filtered);

    let filter_disabled = configurable_filter(false);
    let filtered: Vec<_> = numbers
        .iter()
        .copied()
        .filter(filter_disabled.into_fn())
        .collect();
    println!("Filter disabled: {:?} -> {:?}", numbers, filtered);
}

pub fn not(self) -> BoxPredicate<T>

Returns a predicate that represents the logical negation of this predicate.

This method consumes self due to single-ownership semantics.

Returns

A new BoxPredicate representing the logical negation.

pub fn nand<P>(self, other: P) -> BoxPredicate<T>

where P: Predicate<T> + 'static,

Returns a predicate that represents the logical NAND (NOT AND) of this predicate and another.

NAND returns true unless both predicates are true. Equivalent to !(self AND other).

This method consumes self due to single-ownership semantics.

Parameters

• other - The other predicate to combine with. 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
  • Another BoxPredicate<T>
  • An RcPredicate<T>
  • An ArcPredicate<T>
  • Any type implementing Predicate<T>

Returns

A new BoxPredicate representing the logical NAND.

Examples

Combining with closures

use prism3_function::predicate::{Predicate, BoxPredicate};

let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
let is_even = |x: &i32| x % 2 == 0;

// Note: is_positive is moved here, so it's no longer usable
let nand = is_positive.nand(is_even);
assert!(nand.test(&3));   // positive but odd: !(true && false) = true
assert!(nand.test(&-2));  // even but negative: !(false && true) = true
assert!(!nand.test(&4));  // positive and even: !(true && true) = false
// is_positive.test(&5); // This would not compile - is_positive was moved

Combining with function pointers

use prism3_function::predicate::{Predicate, BoxPredicate};

fn is_even(x: &i32) -> bool { x % 2 == 0 }

let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
let nand = is_positive.nand(is_even);

assert!(nand.test(&3));
assert!(!nand.test(&4));

Combining with other BoxPredicate

use prism3_function::predicate::{Predicate, BoxPredicate};

let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
let is_even = BoxPredicate::new(|x: &i32| x % 2 == 0);

let nand = is_positive.nand(is_even);
assert!(nand.test(&3));   // returns true when only one condition is met
assert!(!nand.test(&4));  // returns false when both conditions are met

Preserving original predicates with clone

use prism3_function::predicate::{Predicate, BoxPredicate};

let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
let is_even = BoxPredicate::new(|x: &i32| x % 2 == 0);

// Clone the predicates to preserve them for later use
let nand = is_positive.clone().nand(is_even.clone());
assert!(nand.test(&3));   // returns true when only one condition is met
assert!(!nand.test(&4));  // returns false when both conditions are met

// Original predicates are still usable
assert!(is_positive.test(&5));
assert!(is_even.test(&6));

pub fn xor<P>(self, other: P) -> BoxPredicate<T>

where P: Predicate<T> + 'static,

Returns a predicate that represents the logical XOR (exclusive OR) of this predicate and another.

XOR returns true if exactly one of the predicates is true.

This method consumes self due to single-ownership semantics.

Parameters

• other - The other predicate to combine with. 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
  • Another BoxPredicate<T>
  • An RcPredicate<T>
  • An ArcPredicate<T>
  • Any type implementing Predicate<T>

Returns

A new BoxPredicate representing the logical XOR.

Examples

Combining with closures

use prism3_function::predicate::{Predicate, BoxPredicate};

let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
let is_even = |x: &i32| x % 2 == 0;

// Note: is_positive is moved here, so it's no longer usable
let xor = is_positive.xor(is_even);
assert!(xor.test(&3));    // positive but odd: true ^ false = true
assert!(xor.test(&-2));   // even but negative: false ^ true = true
assert!(!xor.test(&4));   // positive and even: true ^ true = false
assert!(!xor.test(&-1));  // negative and odd: false ^ false = false
// is_positive.test(&5); // This would not compile - is_positive was moved

Combining with function pointers

use prism3_function::predicate::{Predicate, BoxPredicate};

fn is_even(x: &i32) -> bool { x % 2 == 0 }

let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
let xor = is_positive.xor(is_even);

assert!(xor.test(&3));
assert!(!xor.test(&4));

Combining with other BoxPredicate

use prism3_function::predicate::{Predicate, BoxPredicate};

let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
let is_even = BoxPredicate::new(|x: &i32| x % 2 == 0);

let xor = is_positive.xor(is_even);
assert!(xor.test(&3));    // returns true when only one condition is met
assert!(!xor.test(&4));   // returns false when both conditions are met
assert!(!xor.test(&-1));  // returns false when neither condition is met

Preserving original predicates with clone

use prism3_function::predicate::{Predicate, BoxPredicate};

let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
let is_even = BoxPredicate::new(|x: &i32| x % 2 == 0);

// Clone the predicates to preserve them for later use
let xor = is_positive.clone().xor(is_even.clone());
assert!(xor.test(&3));    // returns true when only one condition is met
assert!(!xor.test(&4));   // returns false when both conditions are met
assert!(!xor.test(&-1));  // returns false when neither condition is met

// Original predicates are still usable
assert!(is_positive.test(&5));
assert!(is_even.test(&6));

pub fn nor<P>(self, other: P) -> BoxPredicate<T>

where P: Predicate<T> + 'static,

Returns a predicate that represents the logical NOR (NOT OR) of this predicate and another.

NOR returns true only when both predicates are false. Equivalent to !(self OR other).

This method consumes self due to single-ownership semantics.

Parameters

• other - The other predicate to combine with. 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
  • Another BoxPredicate<T>
  • An RcPredicate<T>
  • An ArcPredicate<T>
  • Any type implementing Predicate<T>

Returns

A new BoxPredicate representing the logical NOR.

Examples

Combining with closures

use prism3_function::predicate::{Predicate, BoxPredicate};

let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
let is_even = |x: &i32| x % 2 == 0;

// Note: is_positive is moved here, so it's no longer usable
let nor = is_positive.nor(is_even);
assert!(nor.test(&-3));   // Neither positive nor even:
                          // !(false || false) = true
assert!(!nor.test(&4));   // Both positive and even:
                          // !(true || true) = false
assert!(!nor.test(&3));   // Positive but not even:
                          // !(true || false) = false
assert!(!nor.test(&-2));  // Even but not positive:
                          // !(false || true) = false
// is_positive.test(&5); // This would not compile - is_positive was moved

Combining with function pointers

use prism3_function::predicate::{Predicate, BoxPredicate};

fn is_even(x: &i32) -> bool { x % 2 == 0 }

let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
let nor = is_positive.nor(is_even);

assert!(nor.test(&-3));
assert!(!nor.test(&4));

Combining with other BoxPredicate

use prism3_function::predicate::{Predicate, BoxPredicate};

let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
let is_even = BoxPredicate::new(|x: &i32| x % 2 == 0);

let nor = is_positive.nor(is_even);
assert!(nor.test(&-3));   // Returns true only when both are false
assert!(!nor.test(&4));   // Returns false when at least one is true

Preserving original predicates with clone

use prism3_function::predicate::{Predicate, BoxPredicate};

let is_positive = BoxPredicate::new(|x: &i32| *x > 0);
let is_even = BoxPredicate::new(|x: &i32| x % 2 == 0);

// Clone the predicates to preserve them for later use
let nor = is_positive.clone().nor(is_even.clone());
assert!(nor.test(&-3));   // Returns true only when both are false
assert!(!nor.test(&4));   // Returns false when at least one is true

// Original predicates are still usable
assert!(is_positive.test(&5));
assert!(is_even.test(&6));

Trait Implementations

impl<T> Debug for BoxPredicate<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Implements Debug trait for BoxPredicate

Shows the predicate name in debug struct format.

impl<T> Display for BoxPredicate<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Implements Display trait for BoxPredicate

Shows the predicate name if available, or “unnamed” as default.

impl<T: 'static> Predicate<T> for BoxPredicate<T>

fn test(&self, value: &T) -> bool

Tests whether the given value satisfies this predicate.

fn into_box(self) -> BoxPredicate<T>

Converts this predicate into a BoxPredicate.

fn into_rc(self) -> RcPredicate<T>

Converts this predicate into an RcPredicate.

fn into_fn(self) -> impl Fn(&T) -> bool

Converts this predicate into a closure that can be used directly with standard library methods.

fn into_arc(self) -> ArcPredicate<T>

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

Converts this predicate into an ArcPredicate.