Struct RcPredicate 

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

An Rc-based predicate with single-threaded shared ownership.

This type is suitable for scenarios where the predicate needs to be reused in a single-threaded context. Composition methods borrow &self, allowing the original predicate to remain usable after composition.

Examples

use qubit_function::{Predicate, RcPredicate};

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

// Original predicate remains usable after composition
let combined = pred.and(RcPredicate::new(|x| x % 2 == 0));
assert!(pred.test(&5));  // Still works

Implementations

impl<T> RcPredicate<T>

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

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

Creates a new predicate.

Wraps the provided closure in the appropriate smart pointer type for this predicate implementation.

Examples found in repository

examples/predicates/predicate_fn_mut_demo.rs (line 47)

fn demo_with_vec_retain() {
    println!("2. Using Vec::retain");

    // RcPredicate example
    let pred = RcPredicate::new(|x: &i32| *x % 2 == 0);
    let mut numbers = vec![1, 2, 3, 4, 5, 6];
    println!("   Original data: {:?}", numbers);
    numbers.retain(pred.to_fn());
    println!("   Retained even numbers: {:?}", numbers);
    assert_eq!(numbers, vec![2, 4, 6]);

    // Original predicate is still available
    assert!(pred.test(&10));
    println!("   ✓ RcPredicate::to_fn() can be used in retain");
    println!("   ✓ Original predicate is still available\n");
}

/// Demonstrates usage with generic functions that require FnMut
fn demo_with_generic_function() {
    println!("3. Using generic functions (requires FnMut)");

    fn count_matching<F>(items: &[i32], mut predicate: F) -> usize
    where
        F: FnMut(&i32) -> bool,
    {
        items.iter().filter(|x| predicate(x)).count()
    }

    let pred = RcPredicate::new(|x: &i32| *x > 10);
    let count1 = count_matching(&[5, 15, 8, 20], pred.to_fn());
    println!("   First call: count = {}", count1);
    assert_eq!(count1, 2);

    // Original predicate can be reused
    let count2 = count_matching(&[12, 3, 18], pred.to_fn());
    println!("   Second call: count = {}", count2);
    assert_eq!(count2, 2);

    println!("   ✓ RcPredicate::to_fn() can be passed to generic functions requiring FnMut");
    println!("   ✓ Original predicate can be converted and used multiple times\n");
}

examples/predicates/predicate_set_name_demo.rs (line 66)

fn demo_rc_predicate() {
    println!("2. RcPredicate Naming Functionality");

    // Using new_with_name
    let pred1 = RcPredicate::new_with_name("greater_than_10", |x: &i32| *x > 10);
    println!("   Using new_with_name:");
    println!("     Name: {:?}", pred1.name());
    println!("     Test 15: {}", pred1.test(&15));

    // Using set_name
    let mut pred2 = RcPredicate::new(|x: &i32| *x < 100);
    println!("\n   Using set_name:");
    println!("     Initial name: {:?}", pred2.name());
    pred2.set_name("less_than_100");
    println!("     Name after setting: {:?}", pred2.name());
    println!("     Test 50: {}", pred2.test(&50));

    // Name is preserved after cloning
    let pred3 = pred2.clone();
    println!("\n   Name preserved after cloning:");
    println!("     Cloned name: {:?}", pred3.name());
    println!("     Test 80: {}\n", pred3.test(&80));
}

examples/predicates/predicate_demo.rs (line 106)

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().expect("thread should not panic");
    }

    // 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;
    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().expect("mutex should not be poisoned");
            *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().expect("thread should not panic");

    println!(
        "  Total call count: {}",
        counter_clone.lock().expect("mutex should not be poisoned")
    );
}

/// Practical use cases
fn practical_use_cases() {
    println!("--- 7. Practical Use Cases ---");

    // Validation rules
    println!("Scenario 1: Form Validation");
    struct User {
        name: String,
        age: i32,
        email: String,
    }

    let name_valid = RcPredicate::new_with_name("name_not_empty", |user: &User| !user.name.is_empty());

    let age_valid = RcPredicate::new_with_name("age_between_18_120", |user: &User| user.age >= 18 && user.age <= 120);

    let email_valid = RcPredicate::new_with_name("email_contains_at", |user: &User| user.email.contains('@'));

    let all_valid = name_valid.and(age_valid.clone()).and(email_valid.clone());

    let user1 = User {
        name: "Alice".to_string(),
        age: 25,
        email: "alice@example.com".to_string(),
    };

    let user2 = User {
        name: "".to_string(),
        age: 25,
        email: "bob@example.com".to_string(),
    };

    println!("  user1 validation: {}", all_valid.test(&user1));
    println!("  user2 validation: {}", all_valid.test(&user2));

    // Filter pipeline
    println!("\nScenario 2: Data Filtering Pipeline");
    let numbers: Vec<i32> = (-10..=10).collect();

    let positive = |x: &i32| *x > 0;
    let even = |x: &i32| x % 2 == 0;
    let less_than_eight = |x: &i32| *x < 8;

    let filtered: Vec<i32> = numbers
        .iter()
        .filter(|x| positive.test(x))
        .filter(|x| even.test(x))
        .filter(|x| less_than_eight.test(x))
        .copied()
        .collect();

    println!("  Filtered numbers: {:?}", filtered);

    // Strategy pattern
    println!("\nScenario 3: Strategy Pattern");
    let mut strategies: HashMap<&str, RcPredicate<i32>> = HashMap::new();
    strategies.insert("positive", RcPredicate::new(|x: &i32| *x > 0));
    strategies.insert("negative", RcPredicate::new(|x: &i32| *x < 0));
    strategies.insert("even", RcPredicate::new(|x: &i32| x % 2 == 0));

    let test_value = 4;
    for (name, pred) in strategies.iter() {
        println!("  {} strategy test {}: {}", name, test_value, pred.test(&test_value));
    }
}

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

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

Creates a new named predicate.

Wraps the provided closure and assigns it a name, which is useful for debugging and logging purposes.

Examples found in repository

examples/predicates/predicate_set_name_demo.rs (line 60)

fn demo_rc_predicate() {
    println!("2. RcPredicate Naming Functionality");

    // Using new_with_name
    let pred1 = RcPredicate::new_with_name("greater_than_10", |x: &i32| *x > 10);
    println!("   Using new_with_name:");
    println!("     Name: {:?}", pred1.name());
    println!("     Test 15: {}", pred1.test(&15));

    // Using set_name
    let mut pred2 = RcPredicate::new(|x: &i32| *x < 100);
    println!("\n   Using set_name:");
    println!("     Initial name: {:?}", pred2.name());
    pred2.set_name("less_than_100");
    println!("     Name after setting: {:?}", pred2.name());
    println!("     Test 50: {}", pred2.test(&50));

    // Name is preserved after cloning
    let pred3 = pred2.clone();
    println!("\n   Name preserved after cloning:");
    println!("     Cloned name: {:?}", pred3.name());
    println!("     Test 80: {}\n", pred3.test(&80));
}

examples/predicates/predicate_demo.rs (line 160)

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;
    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().expect("mutex should not be poisoned");
            *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().expect("thread should not panic");

    println!(
        "  Total call count: {}",
        counter_clone.lock().expect("mutex should not be poisoned")
    );
}

/// Practical use cases
fn practical_use_cases() {
    println!("--- 7. Practical Use Cases ---");

    // Validation rules
    println!("Scenario 1: Form Validation");
    struct User {
        name: String,
        age: i32,
        email: String,
    }

    let name_valid = RcPredicate::new_with_name("name_not_empty", |user: &User| !user.name.is_empty());

    let age_valid = RcPredicate::new_with_name("age_between_18_120", |user: &User| user.age >= 18 && user.age <= 120);

    let email_valid = RcPredicate::new_with_name("email_contains_at", |user: &User| user.email.contains('@'));

    let all_valid = name_valid.and(age_valid.clone()).and(email_valid.clone());

    let user1 = User {
        name: "Alice".to_string(),
        age: 25,
        email: "alice@example.com".to_string(),
    };

    let user2 = User {
        name: "".to_string(),
        age: 25,
        email: "bob@example.com".to_string(),
    };

    println!("  user1 validation: {}", all_valid.test(&user1));
    println!("  user2 validation: {}", all_valid.test(&user2));

    // Filter pipeline
    println!("\nScenario 2: Data Filtering Pipeline");
    let numbers: Vec<i32> = (-10..=10).collect();

    let positive = |x: &i32| *x > 0;
    let even = |x: &i32| x % 2 == 0;
    let less_than_eight = |x: &i32| *x < 8;

    let filtered: Vec<i32> = numbers
        .iter()
        .filter(|x| positive.test(x))
        .filter(|x| even.test(x))
        .filter(|x| less_than_eight.test(x))
        .copied()
        .collect();

    println!("  Filtered numbers: {:?}", filtered);

    // Strategy pattern
    println!("\nScenario 3: Strategy Pattern");
    let mut strategies: HashMap<&str, RcPredicate<i32>> = HashMap::new();
    strategies.insert("positive", RcPredicate::new(|x: &i32| *x > 0));
    strategies.insert("negative", RcPredicate::new(|x: &i32| *x < 0));
    strategies.insert("even", RcPredicate::new(|x: &i32| x % 2 == 0));

    let test_value = 4;
    for (name, pred) in strategies.iter() {
        println!("  {} strategy test {}: {}", name, test_value, pred.test(&test_value));
    }
}

pub fn new_with_optional_name<F>(f: F, name: Option<String>) -> Self

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

Creates a new named predicate with an optional name.

Wraps the provided closure and assigns it an optional name.

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

Gets the name of this predicate.

Returns

Returns Some(&str) if a name was set, None otherwise.

Examples found in repository

examples/predicates/predicate_set_name_demo.rs (line 62)

fn demo_rc_predicate() {
    println!("2. RcPredicate Naming Functionality");

    // Using new_with_name
    let pred1 = RcPredicate::new_with_name("greater_than_10", |x: &i32| *x > 10);
    println!("   Using new_with_name:");
    println!("     Name: {:?}", pred1.name());
    println!("     Test 15: {}", pred1.test(&15));

    // Using set_name
    let mut pred2 = RcPredicate::new(|x: &i32| *x < 100);
    println!("\n   Using set_name:");
    println!("     Initial name: {:?}", pred2.name());
    pred2.set_name("less_than_100");
    println!("     Name after setting: {:?}", pred2.name());
    println!("     Test 50: {}", pred2.test(&50));

    // Name is preserved after cloning
    let pred3 = pred2.clone();
    println!("\n   Name preserved after cloning:");
    println!("     Cloned name: {:?}", pred3.name());
    println!("     Test 80: {}\n", pred3.test(&80));
}

examples/predicates/predicate_demo.rs (line 166)

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;
    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));
}

examples/predicates/always_predicate_demo.rs (line 43)

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 name to set for this predicate

Examples found in repository

examples/predicates/predicate_set_name_demo.rs (line 69)

fn demo_rc_predicate() {
    println!("2. RcPredicate Naming Functionality");

    // Using new_with_name
    let pred1 = RcPredicate::new_with_name("greater_than_10", |x: &i32| *x > 10);
    println!("   Using new_with_name:");
    println!("     Name: {:?}", pred1.name());
    println!("     Test 15: {}", pred1.test(&15));

    // Using set_name
    let mut pred2 = RcPredicate::new(|x: &i32| *x < 100);
    println!("\n   Using set_name:");
    println!("     Initial name: {:?}", pred2.name());
    pred2.set_name("less_than_100");
    println!("     Name after setting: {:?}", pred2.name());
    println!("     Test 50: {}", pred2.test(&50));

    // Name is preserved after cloning
    let pred3 = pred2.clone();
    println!("\n   Name preserved after cloning:");
    println!("     Cloned name: {:?}", pred3.name());
    println!("     Test 80: {}\n", pred3.test(&80));
}

pub fn clear_name(&mut self)

Clears the name of this predicate.

pub fn always_true() -> Self

Creates a predicate that always returns true.

Returns

A new RcPredicate that always returns true.

Examples found in repository

examples/predicates/always_predicate_demo.rs (line 39)

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 RcPredicate that always returns false.

Examples found in repository

examples/predicates/always_predicate_demo.rs (line 46)

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 and<P>(&self, other: P) -> RcPredicate<T>

where T: 'static, P: Predicate<T> + 'static,

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

This method borrows self; the original shared predicate remains usable.

Parameters

• other - The other predicate to combine with.

Returns

A new predicate representing the logical AND.

Examples found in repository

examples/predicates/predicate_demo.rs (line 110)

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().expect("thread should not panic");
    }

    // 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;
    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().expect("mutex should not be poisoned");
            *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().expect("thread should not panic");

    println!(
        "  Total call count: {}",
        counter_clone.lock().expect("mutex should not be poisoned")
    );
}

/// Practical use cases
fn practical_use_cases() {
    println!("--- 7. Practical Use Cases ---");

    // Validation rules
    println!("Scenario 1: Form Validation");
    struct User {
        name: String,
        age: i32,
        email: String,
    }

    let name_valid = RcPredicate::new_with_name("name_not_empty", |user: &User| !user.name.is_empty());

    let age_valid = RcPredicate::new_with_name("age_between_18_120", |user: &User| user.age >= 18 && user.age <= 120);

    let email_valid = RcPredicate::new_with_name("email_contains_at", |user: &User| user.email.contains('@'));

    let all_valid = name_valid.and(age_valid.clone()).and(email_valid.clone());

    let user1 = User {
        name: "Alice".to_string(),
        age: 25,
        email: "alice@example.com".to_string(),
    };

    let user2 = User {
        name: "".to_string(),
        age: 25,
        email: "bob@example.com".to_string(),
    };

    println!("  user1 validation: {}", all_valid.test(&user1));
    println!("  user2 validation: {}", all_valid.test(&user2));

    // Filter pipeline
    println!("\nScenario 2: Data Filtering Pipeline");
    let numbers: Vec<i32> = (-10..=10).collect();

    let positive = |x: &i32| *x > 0;
    let even = |x: &i32| x % 2 == 0;
    let less_than_eight = |x: &i32| *x < 8;

    let filtered: Vec<i32> = numbers
        .iter()
        .filter(|x| positive.test(x))
        .filter(|x| even.test(x))
        .filter(|x| less_than_eight.test(x))
        .copied()
        .collect();

    println!("  Filtered numbers: {:?}", filtered);

    // Strategy pattern
    println!("\nScenario 3: Strategy Pattern");
    let mut strategies: HashMap<&str, RcPredicate<i32>> = HashMap::new();
    strategies.insert("positive", RcPredicate::new(|x: &i32| *x > 0));
    strategies.insert("negative", RcPredicate::new(|x: &i32| *x < 0));
    strategies.insert("even", RcPredicate::new(|x: &i32| x % 2 == 0));

    let test_value = 4;
    for (name, pred) in strategies.iter() {
        println!("  {} strategy test {}: {}", name, test_value, pred.test(&test_value));
    }
}

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

where T: 'static, P: Predicate<T> + 'static,

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

This method borrows self; the original shared predicate remains usable.

Parameters

• other - The other predicate to combine with.

Returns

A new predicate representing the logical OR.

Examples found in repository

examples/predicates/predicate_demo.rs (line 111)

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().expect("thread should not panic");
    }

    // 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;
    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));
}

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

where T: 'static, 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 borrows self; the original shared predicate remains usable.

Parameters

• other - The other predicate to combine with.

Returns

A new predicate representing the logical NAND.

Examples found in repository

examples/predicates/predicate_demo.rs (line 183)

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;
    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));
}

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

where T: 'static, 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 borrows self; the original shared predicate remains usable.

Parameters

• other - The other predicate to combine with.

Returns

A new predicate representing the logical XOR.

Examples found in repository

examples/predicates/predicate_demo.rs (line 189)

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;
    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));
}

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

where T: 'static, 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 borrows self; the original shared predicate remains usable.

Parameters

• other - The other predicate to combine with.

Returns

A new predicate representing the logical NOR.

Examples found in repository

examples/predicates/predicate_demo.rs (line 196)

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;
    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));
}

Trait Implementations

impl<T> Clone for RcPredicate<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for RcPredicate<T>

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

Formats the value using the given formatter.

impl<T> Display for RcPredicate<T>

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

Formats the value using the given formatter.

impl<T> Not for &RcPredicate<T>

where T: 'static,

type Output = RcPredicate<T>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T> Not for RcPredicate<T>

where T: 'static,

type Output = RcPredicate<T>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T> Predicate<T> for RcPredicate<T>

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

Tests whether the given value satisfies this predicate.

fn into_box(self) -> BoxPredicate<T>

where Self: 'static,

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 to_box(&self) -> BoxPredicate<T>

where Self: 'static,

Converts a reference to this predicate into a BoxPredicate.

fn to_rc(&self) -> RcPredicate<T>

Converts a reference to this predicate into an RcPredicate.

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

Converts a reference to 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,

Converts this predicate into an ArcPredicate.

fn to_arc(&self) -> ArcPredicate<T>

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

Converts a reference to this predicate into an ArcPredicate.