predicate_fn_mut_demo/
predicate_fn_mut_demo.rs

1/*******************************************************************************
2 *
3 *    Copyright (c) 2025.
4 *    3-Prism Co. Ltd.
5 *
6 *    All rights reserved.
7 *
8 ******************************************************************************/
9
10//! Demonstrates how Predicate's into_fn/to_fn methods can be used in scenarios requiring FnMut
11
12use prism3_function::predicate::{ArcPredicate, BoxPredicate, Predicate, RcPredicate};
13
14fn main() {
15    println!("=== Demonstrating Predicate compatibility with FnMut ===\n");
16
17    demo_with_iterator_filter();
18    demo_with_vec_retain();
19    demo_with_generic_function();
20    demo_thread_safe();
21}
22
23/// Demonstrates usage with Iterator::filter (filter requires FnMut)
24fn demo_with_iterator_filter() {
25    println!("1. Using Iterator::filter");
26
27    let pred = BoxPredicate::new(|x: &i32| *x > 0);
28    let numbers = vec![-2, -1, 0, 1, 2, 3];
29    let positives: Vec<_> = numbers.iter().copied().filter(pred.into_fn()).collect();
30    println!("   Original data: {:?}", numbers);
31    println!("   Filtered result: {:?}", positives);
32    assert_eq!(positives, vec![1, 2, 3]);
33    println!("   ✓ BoxPredicate::into_fn() can be used in filter\n");
34}
35
36/// Demonstrates usage with Vec::retain (retain requires FnMut)
37fn demo_with_vec_retain() {
38    println!("2. Using Vec::retain");
39
40    // RcPredicate example
41    let pred = RcPredicate::new(|x: &i32| *x % 2 == 0);
42    let mut numbers = vec![1, 2, 3, 4, 5, 6];
43    println!("   Original data: {:?}", numbers);
44    numbers.retain(pred.to_fn());
45    println!("   Retained even numbers: {:?}", numbers);
46    assert_eq!(numbers, vec![2, 4, 6]);
47
48    // Original predicate is still available
49    assert!(pred.test(&10));
50    println!("   ✓ RcPredicate::to_fn() can be used in retain");
51    println!("   ✓ Original predicate is still available\n");
52}
53
54/// Demonstrates usage with generic functions that require FnMut
55fn demo_with_generic_function() {
56    println!("3. Using generic functions (requires FnMut)");
57
58    fn count_matching<F>(items: &[i32], mut predicate: F) -> usize
59    where
60        F: FnMut(&i32) -> bool,
61    {
62        items.iter().filter(|x| predicate(x)).count()
63    }
64
65    let pred = RcPredicate::new(|x: &i32| *x > 10);
66    let count1 = count_matching(&[5, 15, 8, 20], pred.to_fn());
67    println!("   First call: count = {}", count1);
68    assert_eq!(count1, 2);
69
70    // Original predicate can be reused
71    let count2 = count_matching(&[12, 3, 18], pred.to_fn());
72    println!("   Second call: count = {}", count2);
73    assert_eq!(count2, 2);
74
75    println!("   ✓ RcPredicate::to_fn() can be passed to generic functions requiring FnMut");
76    println!("   ✓ Original predicate can be converted and used multiple times\n");
77}
78
79/// Demonstrates thread-safe usage
80fn demo_thread_safe() {
81    println!("4. Thread-safe usage");
82
83    let pred = ArcPredicate::new(|x: &i32| *x > 0);
84    // clone and convert into a 'static closure so it can be moved to another thread
85    let closure = pred.clone().into_fn();
86
87    // Closure can be passed between threads
88    let handle = std::thread::spawn(move || {
89        let numbers = [-2, -1, 0, 1, 2, 3];
90        numbers.iter().copied().filter(closure).count()
91    });
92
93    let count = handle.join().unwrap();
94    println!("   Filtered result count in thread: {}", count);
95    assert_eq!(count, 3);
96
97    // Original predicate is still available
98    assert!(pred.test(&5));
99    println!("   ✓ ArcPredicate::to_fn() returns a thread-safe closure");
100    println!("   ✓ Original predicate is still available in main thread\n");
101}
predicate_fn_mut_demo/predicate_fn_mut_demo.rs

predicate_fn_mut_demo/
predicate_fn_mut_demo.rs
