Struct ArcBiPredicate 

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

An Arc-based bi-predicate with thread-safe shared ownership.

This type is suitable for scenarios where the bi-predicate needs to be shared across threads. Composition methods borrow &self, allowing the original bi-predicate to remain usable after composition.

Examples

use qubit_function::{BiPredicate, ArcBiPredicate};

let pred = ArcBiPredicate::new(|x: &i32, y: &i32| x + y > 0);
assert!(pred.test(&5, &3));

// Original bi-predicate remains usable after composition
let combined = pred.and(ArcBiPredicate::new(|x, y| x > y));
assert!(pred.test(&5, &3));  // Still works

// Can be cloned and sent across threads
let pred_clone = pred.clone();
std::thread::spawn(move || {
    assert!(pred_clone.test(&10, &5));
}).join().unwrap();

Implementations

impl<T, U> ArcBiPredicate<T, U>

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

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

Creates a new bi-predicate.

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

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

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

Creates a new named bi-predicate.

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

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

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

Creates a new named bi-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 bi-predicate.

Returns

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

Examples found in repository

examples/predicates/always_bi_predicate_demo.rs (line 83)

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

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

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

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

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

    // RcBiPredicate::always_false
    let rc_always_false: RcBiPredicate<String, i32> = RcBiPredicate::always_false();
    println!("\nRcBiPredicate::always_false():");
    println!(
        "  test(&\"hello\", &5): {}",
        rc_always_false.test(&"hello".to_string(), &5)
    );
    println!(
        "  test(&\"world\", &-3): {}",
        rc_always_false.test(&"world".to_string(), &-3)
    );
    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\", &1): {}",
        rc_always_true.test(&"test".to_string(), &1)
    );
    println!(
        "  Clone: test(&\"test\", &2): {}",
        rc_clone.test(&"test".to_string(), &2)
    );

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

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

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

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

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

    // Combining with always_false (AND)
    let sum_positive = BoxBiPredicate::new(|x: &i32, y: &i32| x + y > 0);
    let combined_and_false = sum_positive.and(BoxBiPredicate::always_false());
    println!("\nsum_positive AND always_false:");
    println!(
        "  test(&5, &3): {} (always false)",
        combined_and_false.test(&5, &3)
    );
    println!(
        "  test(&-3, &-5): {} (always false)",
        combined_and_false.test(&-3, &-5)
    );

    // Combining with always_true (OR)
    let sum_positive = BoxBiPredicate::new(|x: &i32, y: &i32| x + y > 0);
    let combined_or_true = sum_positive.or(BoxBiPredicate::always_true());
    println!("\nsum_positive OR always_true:");
    println!(
        "  test(&5, &3): {} (always true)",
        combined_or_true.test(&5, &3)
    );
    println!(
        "  test(&-3, &-5): {} (always true)",
        combined_or_true.test(&-3, &-5)
    );

    // Combining with always_false (OR)
    let sum_positive = BoxBiPredicate::new(|x: &i32, y: &i32| x + y > 0);
    let combined_or_false = sum_positive.or(BoxBiPredicate::always_false());
    println!("\nsum_positive OR always_false:");
    println!(
        "  test(&5, &3): {} (equivalent to sum_positive)",
        combined_or_false.test(&5, &3)
    );
    println!(
        "  test(&-3, &-5): {} (equivalent to sum_positive)",
        combined_or_false.test(&-3, &-5)
    );

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

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

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

    // Scenario 3: Configurable filter
    fn configurable_filter(enable_filter: bool) -> BoxBiPredicate<i32, i32> {
        if enable_filter {
            BoxBiPredicate::new(|x: &i32, y: &i32| x + y > 5)
        } else {
            BoxBiPredicate::always_true()
        }
    }

    let pairs = vec![(1, 2), (3, 4), (5, 6)];

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

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

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

Sets the name of this bi-predicate.

Parameters

• name - The name to set for this bi-predicate

pub fn clear_name(&mut self)

Clears the name of this bi-predicate.

pub fn always_true() -> Self

Creates a bi-predicate that always returns true.

Returns

A new ArcBiPredicate that always returns true.

Examples found in repository

examples/predicates/always_bi_predicate_demo.rs (line 79)

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

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

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

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

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

    // RcBiPredicate::always_false
    let rc_always_false: RcBiPredicate<String, i32> = RcBiPredicate::always_false();
    println!("\nRcBiPredicate::always_false():");
    println!(
        "  test(&\"hello\", &5): {}",
        rc_always_false.test(&"hello".to_string(), &5)
    );
    println!(
        "  test(&\"world\", &-3): {}",
        rc_always_false.test(&"world".to_string(), &-3)
    );
    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\", &1): {}",
        rc_always_true.test(&"test".to_string(), &1)
    );
    println!(
        "  Clone: test(&\"test\", &2): {}",
        rc_clone.test(&"test".to_string(), &2)
    );

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

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

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

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

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

    // Combining with always_false (AND)
    let sum_positive = BoxBiPredicate::new(|x: &i32, y: &i32| x + y > 0);
    let combined_and_false = sum_positive.and(BoxBiPredicate::always_false());
    println!("\nsum_positive AND always_false:");
    println!(
        "  test(&5, &3): {} (always false)",
        combined_and_false.test(&5, &3)
    );
    println!(
        "  test(&-3, &-5): {} (always false)",
        combined_and_false.test(&-3, &-5)
    );

    // Combining with always_true (OR)
    let sum_positive = BoxBiPredicate::new(|x: &i32, y: &i32| x + y > 0);
    let combined_or_true = sum_positive.or(BoxBiPredicate::always_true());
    println!("\nsum_positive OR always_true:");
    println!(
        "  test(&5, &3): {} (always true)",
        combined_or_true.test(&5, &3)
    );
    println!(
        "  test(&-3, &-5): {} (always true)",
        combined_or_true.test(&-3, &-5)
    );

    // Combining with always_false (OR)
    let sum_positive = BoxBiPredicate::new(|x: &i32, y: &i32| x + y > 0);
    let combined_or_false = sum_positive.or(BoxBiPredicate::always_false());
    println!("\nsum_positive OR always_false:");
    println!(
        "  test(&5, &3): {} (equivalent to sum_positive)",
        combined_or_false.test(&5, &3)
    );
    println!(
        "  test(&-3, &-5): {} (equivalent to sum_positive)",
        combined_or_false.test(&-3, &-5)
    );

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

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

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

    // Scenario 3: Configurable filter
    fn configurable_filter(enable_filter: bool) -> BoxBiPredicate<i32, i32> {
        if enable_filter {
            BoxBiPredicate::new(|x: &i32, y: &i32| x + y > 5)
        } else {
            BoxBiPredicate::always_true()
        }
    }

    let pairs = vec![(1, 2), (3, 4), (5, 6)];

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

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

pub fn always_false() -> Self

Creates a bi-predicate that always returns false.

Returns

A new ArcBiPredicate that always returns false.

Examples found in repository

examples/predicates/always_bi_predicate_demo.rs (line 86)

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

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

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

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

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

    // RcBiPredicate::always_false
    let rc_always_false: RcBiPredicate<String, i32> = RcBiPredicate::always_false();
    println!("\nRcBiPredicate::always_false():");
    println!(
        "  test(&\"hello\", &5): {}",
        rc_always_false.test(&"hello".to_string(), &5)
    );
    println!(
        "  test(&\"world\", &-3): {}",
        rc_always_false.test(&"world".to_string(), &-3)
    );
    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\", &1): {}",
        rc_always_true.test(&"test".to_string(), &1)
    );
    println!(
        "  Clone: test(&\"test\", &2): {}",
        rc_clone.test(&"test".to_string(), &2)
    );

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

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

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

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

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

    // Combining with always_false (AND)
    let sum_positive = BoxBiPredicate::new(|x: &i32, y: &i32| x + y > 0);
    let combined_and_false = sum_positive.and(BoxBiPredicate::always_false());
    println!("\nsum_positive AND always_false:");
    println!(
        "  test(&5, &3): {} (always false)",
        combined_and_false.test(&5, &3)
    );
    println!(
        "  test(&-3, &-5): {} (always false)",
        combined_and_false.test(&-3, &-5)
    );

    // Combining with always_true (OR)
    let sum_positive = BoxBiPredicate::new(|x: &i32, y: &i32| x + y > 0);
    let combined_or_true = sum_positive.or(BoxBiPredicate::always_true());
    println!("\nsum_positive OR always_true:");
    println!(
        "  test(&5, &3): {} (always true)",
        combined_or_true.test(&5, &3)
    );
    println!(
        "  test(&-3, &-5): {} (always true)",
        combined_or_true.test(&-3, &-5)
    );

    // Combining with always_false (OR)
    let sum_positive = BoxBiPredicate::new(|x: &i32, y: &i32| x + y > 0);
    let combined_or_false = sum_positive.or(BoxBiPredicate::always_false());
    println!("\nsum_positive OR always_false:");
    println!(
        "  test(&5, &3): {} (equivalent to sum_positive)",
        combined_or_false.test(&5, &3)
    );
    println!(
        "  test(&-3, &-5): {} (equivalent to sum_positive)",
        combined_or_false.test(&-3, &-5)
    );

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

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

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

    // Scenario 3: Configurable filter
    fn configurable_filter(enable_filter: bool) -> BoxBiPredicate<i32, i32> {
        if enable_filter {
            BoxBiPredicate::new(|x: &i32, y: &i32| x + y > 5)
        } else {
            BoxBiPredicate::always_true()
        }
    }

    let pairs = vec![(1, 2), (3, 4), (5, 6)];

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

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

pub fn and<P>(&self, other: P) -> ArcBiPredicate<T, U>

where T: 'static, U: 'static, P: BiPredicate<T, U> + Send + Sync + 'static,

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

This method consumes self due to single-ownership semantics.

Parameters

• other - The other bi-predicate to combine with.

Returns

A new bi-predicate representing the logical AND.

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

where T: 'static, U: 'static, P: BiPredicate<T, U> + Send + Sync + 'static,

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

This method consumes self due to single-ownership semantics.

Parameters

• other - The other bi-predicate to combine with.

Returns

A new bi-predicate representing the logical OR.

pub fn not(&self) -> ArcBiPredicate<T, U>

where T: 'static, U: 'static,

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

This method consumes self due to single-ownership semantics.

Returns

A new bi-predicate representing the logical negation.

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

where T: 'static, U: 'static, P: BiPredicate<T, U> + Send + Sync + 'static,

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

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

This method consumes self due to single-ownership semantics.

Parameters

• other - The other bi-predicate to combine with.

Returns

A new bi-predicate representing the logical NAND.

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

where T: 'static, U: 'static, P: BiPredicate<T, U> + Send + Sync + 'static,

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

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

This method consumes self due to single-ownership semantics.

Parameters

• other - The other bi-predicate to combine with.

Returns

A new bi-predicate representing the logical XOR.

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

where T: 'static, U: 'static, P: BiPredicate<T, U> + Send + Sync + 'static,

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

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

This method consumes self due to single-ownership semantics.

Parameters

• other - The other bi-predicate to combine with.

Returns

A new bi-predicate representing the logical NOR.

Trait Implementations

impl<T, U> BiPredicate<T, U> for ArcBiPredicate<T, U>

fn test(&self, first: &T, second: &U) -> bool

Tests whether the given values satisfy this bi-predicate.

fn into_box(self) -> BoxBiPredicate<T, U>

where Self: 'static,

Converts this bi-predicate into a BoxBiPredicate.

fn into_rc(self) -> RcBiPredicate<T, U>

where Self: 'static,

Converts this bi-predicate into an RcBiPredicate.

fn into_arc(self) -> ArcBiPredicate<T, U>

Converts this bi-predicate into an ArcBiPredicate.

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

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

fn to_box(&self) -> BoxBiPredicate<T, U>

where Self: 'static,

fn to_rc(&self) -> RcBiPredicate<T, U>

where Self: 'static,

fn to_arc(&self) -> ArcBiPredicate<T, U>

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

impl<T, U> Clone for ArcBiPredicate<T, U>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, U> Debug for ArcBiPredicate<T, U>

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

Formats the value using the given formatter.

impl<T, U> Display for ArcBiPredicate<T, U>

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

Formats the value using the given formatter.