Struct LazyQuery 

pub struct LazyQuery<'a, T, I>
where
    T: 'static,
    I: Iterator<Item = &'a T>,
{ /* private fields */ }

A lazy query builder that uses iterators for deferred execution.

Unlike the standard Query, LazyQuery doesn’t execute until you call a terminal operation like .collect(), .count(), or .first().

Benefits

• Deferred execution: No work until results needed
• Iterator fusion: Rust optimizes chained operations
• Early termination: .take() stops as soon as enough items found
• Composable: Build complex queries by composition

Example

// Nothing executes yet
let query = LazyQuery::new(&products)
    .where_(Product::price_r(), |&p| p < 100.0)
    .where_(Product::stock_r(), |&s| s > 0);

// Execution happens here
let results: Vec<_> = query.collect();

Implementations

impl<'a, T> LazyQuery<'a, T, Iter<'a, T>>

where T: 'static,

pub fn new(data: &'a [T]) -> LazyQuery<'a, T, Iter<'a, T>>

Creates a new lazy query from a slice.

Example

let query = LazyQuery::new(&products);

Examples found in repository

examples/container_support.rs (line 52)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Container Support Demo                                       ║");
    println!("║  Query various collection types                               ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // ============================================================================
    // CONTAINER 1: Vec<T>
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Container 1: Vec<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let vec_products = vec![
        create_sample_product(1, "Laptop", 999, "Electronics"),
        create_sample_product(2, "Mouse", 29, "Electronics"),
        create_sample_product(3, "Desk", 299, "Furniture"),
    ];

    // Query Vec directly
    let vec_query = Query::new(&vec_products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let vec_results = vec_query.all();
    println!("  Vec: Found {} electronics", vec_results.len());

    // Lazy query on Vec
    let lazy_count = LazyQuery::new(&vec_products)
        .where_(Product::price_r(), |&p| p < 100)
        .count();
    println!("  Vec (lazy): {} items under $100", lazy_count);

    // ============================================================================
    // CONTAINER 2: VecDeque<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 2: VecDeque<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut deque_products = VecDeque::new();
    deque_products.push_back(create_sample_product(1, "Keyboard", 129, "Electronics"));
    deque_products.push_back(create_sample_product(2, "Monitor", 349, "Electronics"));
    deque_products.push_back(create_sample_product(3, "Chair", 199, "Furniture"));

    // Convert to owned Vec for querying
    let deque_vec: Vec<Product> = deque_products.iter().cloned().collect();
    let deque_query = Query::new(&deque_vec);
    let deque_count = deque_query.count();
    println!("  VecDeque: {} total items", deque_count);

    // More efficient: use make_contiguous for zero-copy slice access
    let contiguous = deque_products.make_contiguous();
    let contiguous_query = Query::new(contiguous);
    println!("  VecDeque (zero-copy): {} items", contiguous_query.count());

    // ============================================================================
    // CONTAINER 3: HashSet<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 3: HashSet<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut set_products = HashSet::new();
    set_products.insert(create_sample_product(1, "Tablet", 499, "Electronics"));
    set_products.insert(create_sample_product(2, "Phone", 799, "Electronics"));
    set_products.insert(create_sample_product(3, "Lamp", 39, "Furniture"));

    // Collect from HashSet to Vec for querying
    let set_vec: Vec<Product> = set_products.iter().cloned().collect();
    let set_query = Query::new(&set_vec)
        .where_(Product::price_r(), |&p| p > 500);
    let expensive = set_query.all();
    println!("  HashSet: {} expensive items", expensive.len());

    // Lazy on HashSet (convert to owned Vec first)
    let set_owned: Vec<Product> = set_products.iter().cloned().collect();
    let lazy_set: Vec<_> = LazyQuery::new(&set_owned)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .collect();
    println!("  HashSet (lazy): {} electronics", lazy_set.len());

    // ============================================================================
    // CONTAINER 4: BTreeSet<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 4: BTreeSet<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut btree_set = BTreeSet::new();
    btree_set.insert(create_sample_product(1, "Webcam", 79, "Electronics"));
    btree_set.insert(create_sample_product(2, "Microphone", 129, "Electronics"));
    btree_set.insert(create_sample_product(3, "Bookshelf", 149, "Furniture"));

    let btree_vec: Vec<Product> = btree_set.iter().cloned().collect();
    let btree_query = Query::new(&btree_vec);
    println!("  BTreeSet: {} total items (sorted order!)", btree_query.count());
    
    // BTreeSet items are in sorted order
    for (i, item) in btree_vec.iter().take(3).enumerate() {
        println!("    {}. {} (ID: {})", i + 1, item.name, item.id);
    }

    // ============================================================================
    // CONTAINER 5: HashMap<K, V> - Query Values
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 5: HashMap<K, V> - Querying values");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut map_products = HashMap::new();
    map_products.insert("prod1", create_sample_product(1, "Speaker", 199, "Electronics"));
    map_products.insert("prod2", create_sample_product(2, "Headphones", 149, "Electronics"));
    map_products.insert("prod3", create_sample_product(3, "Ottoman", 249, "Furniture"));

    // Query HashMap values (convert to owned Vec)
    let map_vec: Vec<Product> = map_products.values().cloned().collect();
    let map_query = Query::new(&map_vec)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = map_query.all();
    println!("  HashMap: {} electronics", electronics.len());

    // ============================================================================
    // CONTAINER 6: BTreeMap<K, V> - Query Values
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 6: BTreeMap<K, V> - Querying values");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut btree_map = BTreeMap::new();
    btree_map.insert(1, create_sample_product(1, "Router", 89, "Electronics"));
    btree_map.insert(2, create_sample_product(2, "Switch", 129, "Electronics"));
    btree_map.insert(3, create_sample_product(3, "Sofa", 899, "Furniture"));

    let btree_map_vec: Vec<Product> = btree_map.values().cloned().collect();
    let btree_map_query = Query::new(&btree_map_vec);
    let avg_price = btree_map_query.sum(Product::price_r()) as f64 / btree_map.len() as f64;
    println!("  BTreeMap: Average price ${:.2}", avg_price);

    // ============================================================================
    // CONTAINER 7: Arrays [T; N]
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 7: Arrays [T; N]");
    println!("═══════════════════════════════════════════════════════════════\n");

    let array_products = [
        create_sample_product(1, "USB Cable", 15, "Electronics"),
        create_sample_product(2, "HDMI Cable", 25, "Electronics"),
        create_sample_product(3, "Power Strip", 35, "Electronics"),
    ];

    // Query array directly (as slice)
    let array_query = Query::new(&array_products);
    let total = array_query.sum(Product::price_r());
    println!("  Array: Total value ${}", total);

    // Lazy on array
    let lazy_array: Vec<_> = LazyQuery::new(&array_products)
        .where_(Product::price_r(), |&p| p > 20)
        .collect();
    println!("  Array (lazy): {} items over $20", lazy_array.len());

    // ============================================================================
    // CONTAINER 8: LinkedList<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 8: LinkedList<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut list_products = LinkedList::new();
    list_products.push_back(create_sample_product(1, "SSD", 159, "Electronics"));
    list_products.push_back(create_sample_product(2, "HDD", 79, "Electronics"));

    let list_vec: Vec<Product> = list_products.iter().cloned().collect();
    let list_query = Query::new(&list_vec);
    println!("  LinkedList: {} items", list_query.count());

    // ============================================================================
    // CONTAINER 9: Option<T> and Result<T, E>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 9: Option<T> and Result<T, E>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let maybe_product = Some(create_sample_product(1, "Mystery Box", 99, "Special"));
    
    if let Some(ref product) = maybe_product {
        let option_query = Query::new(std::slice::from_ref(product));
        println!("  Option (Some): {} items", option_query.count());
    }

    let none_product: Option<Product> = None;
    let none_count = none_product.iter().count();
    println!("  Option (None): {} items", none_count);

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Supported Containers Summary                                  ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Supported container types:");
    println!("   • Vec<T>              - Standard vector");
    println!("   • &[T]                - Slices");
    println!("   • [T; N]              - Fixed-size arrays");
    println!("   • VecDeque<T>         - Double-ended queue");
    println!("   • LinkedList<T>       - Doubly-linked list");
    println!("   • HashSet<T>          - Unordered set");
    println!("   • BTreeSet<T>         - Ordered set");
    println!("   • HashMap<K, V>       - Query values");
    println!("   • BTreeMap<K, V>      - Query values (sorted)");
    println!("   • Option<T>           - 0 or 1 item");
    println!("   • Result<T, E>        - 0 or 1 item\n");

    println!("📝 Usage patterns:");
    println!("   • Direct: Query::new(&container) for Vec, slices, arrays");
    println!("   • Convert: Collect to Vec for Sets and Maps");
    println!("   • Lazy: LazyQuery::new(&slice) for any slice\n");

    println!("💡 Tips:");
    println!("   • Vec/slice: Direct support, most efficient");
    println!("   • Sets: Iterate to Vec, then query");
    println!("   • Maps: Use .values().collect() to query values");
    println!("   • VecDeque: Use .as_slices() for zero-copy");
    println!("   • For custom types: Implement Queryable trait\n");

    println!("✓ Container support demo complete!\n");
}

examples/lazy_evaluation.rs (line 65)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Lazy Query Evaluation Demo                                   ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    let products = create_products();
    println!("Created {} products\n", products.len());

    // ============================================================================
    // DEMO 1: Lazy Execution - Nothing Happens Until .collect()
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 1: Lazy execution - deferred until needed");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Building query (should execute nothing)...");
    let lazy_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            cat == "Electronics"
        });

    let evals_after_build = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Filter evaluations after building query: {}", evals_after_build);
    
    if evals_after_build == 0 {
        println!("  ✅ Confirmed: Query is lazy! Nothing executed yet.\n");
    }

    println!("Collecting results (now it executes)...");
    let results: Vec<_> = lazy_query.collect();

    let evals_after_collect = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Filter evaluations after collecting: {}", evals_after_collect);
    println!("  Results found: {}", results.len());
    println!("  ✅ Query executed exactly once, when needed!\n");

    // ============================================================================
    // DEMO 2: Early Termination - Stops as Soon as Enough Items Found
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 2: Early termination with .take()");
    println!("═══════════════════════════════════════════════════════════════\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);

    println!("Finding first 5 expensive items from 1000 products...");
    let first_5: Vec<_> = LazyQuery::new(&products)
        .where_(Product::price_r(), |p| expensive_check(p))
        .take_lazy(5)
        .collect();

    let ops = EXPENSIVE_OPERATIONS.load(Ordering::SeqCst);
    println!("  Found: {} items", first_5.len());
    println!("  Expensive operations performed: {}", ops);
    println!("  Items NOT checked: {} (stopped early!)", 1000 - ops);
    
    if ops < 1000 {
        println!("  ✅ Early termination worked! Didn't check all 1000 items.\n");
    }

    // ============================================================================
    // DEMO 3: Iterator Fusion - Rust Optimizes Chained Operations
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 3: Iterator fusion - chained operations optimized");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Chaining multiple operations...");
    let chained_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price > 200.0)
        .where_(Product::stock_r(), |&stock| stock > 10)
        .take_lazy(10);

    println!("  Built query with 3 filters + take(10)");
    println!("  ✅ No execution yet - all operations fused into one iterator\n");

    let results: Vec<_> = chained_query.collect();
    println!("  Executed: Found {} items", results.len());
    println!("  ✅ All filters applied in single pass!\n");

    // ============================================================================
    // DEMO 4: Lazy Projection - Only Extract What You Need
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 4: Lazy projection");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .select_lazy(Product::name_r())
        .take(5)  // Only process until we have 5
        .collect();

    println!("  Selected {} names", names.len());
    println!("  ✅ Only evaluated until 5 names found!\n");

    // ============================================================================
    // DEMO 5: Lazy Aggregation - Short-Circuit When Possible
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 5: Short-circuit with .any()");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Checking if ANY electronics exist (1000 items to search)...");
    let exists = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            cat == "Electronics"
        })
        .any();

    let checks = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Result: {}", exists);
    println!("  Items checked: {} out of 1000", checks);
    println!("  Items skipped: {} (short-circuited!)", 1000 - checks);
    
    if checks < 1000 {
        println!("  ✅ Short-circuit worked! Stopped as soon as first match found.\n");
    }

    // ============================================================================
    // DEMO 6: Lazy Find - Stops at First Match
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 6: .find() stops at first match");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Finding first product with price > 500...");
    let found = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            price > 500.0
        })
        .first();

    let checks = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    if let Some(product) = found {
        println!("  Found: {} (${:.2})", product.name, product.price);
    }
    println!("  Items checked: {} out of 1000", checks);
    println!("  ✅ Stopped immediately after finding first match!\n");

    // ============================================================================
    // DEMO 7: Composition - Build Queries Incrementally
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 7: Composable queries");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building base query...");
    let base_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Created base query (not executed)\n");

    println!("  Adding price filter...");
    let refined_query = base_query
        .where_(Product::price_r(), |&price| price > 100.0);

    println!("  Still not executed...\n");

    println!("  Adding stock filter and limiting...");
    let final_query = refined_query
        .where_(Product::stock_r(), |&stock| stock > 5)
        .take_lazy(10);

    println!("  Still not executed...\n");

    println!("  Executing...");
    let results: Vec<_> = final_query.collect();
    println!("  ✅ Executed once with all filters: Found {} items\n", results.len());

    // ============================================================================
    // DEMO 8: For Loop - Natural Iteration
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 8: Use in for loops");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Iterating over filtered products...");
    let mut count = 0;
    for product in LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
    {
        println!("  • {}: ${:.2}", product.name, product.price);
        count += 1;
    }
    println!("  ✅ Processed {} items lazily\n", count);

    // ============================================================================
    // DEMO 9: Performance Comparison
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 9: Performance benefit demonstration");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first expensive item from 1000 products\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);
    
    println!("Without lazy (hypothetical - check all, then take first):");
    println!("  Would check: 1000 items");
    println!("  Would find: ~300 matching items");
    println!("  Would return: 1 item");
    println!("  Wasted work: 299 items processed unnecessarily\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);
    
    println!("With lazy evaluation:");
    let _first = LazyQuery::new(&products)
        .where_(Product::price_r(), |p| expensive_check(p))
        .first();

    let ops = EXPENSIVE_OPERATIONS.load(Ordering::SeqCst);
    println!("  Checked: {} items", ops);
    println!("  Found: 1 item");
    println!("  Wasted work: 0 items");
    println!("  ✅ Efficiency gain: {}x faster!", 1000 / ops.max(1));

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Lazy Evaluation Benefits                                     ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Deferred Execution:");
    println!("   • No work until results needed");
    println!("   • Can build complex queries without performance cost\n");

    println!("✅ Early Termination:");
    println!("   • .take(n) stops after n items");
    println!("   • .first() stops after 1 item");
    println!("   • .any() stops after first match");
    println!("   • Massive performance win for large datasets\n");

    println!("✅ Iterator Fusion:");
    println!("   • Multiple filters combined into one pass");
    println!("   • Rust compiler optimizes chained operations");
    println!("   • No intermediate allocations\n");

    println!("✅ Composable:");
    println!("   • Build queries incrementally");
    println!("   • Reuse query fragments");
    println!("   • Clean separation of query building vs execution\n");

    println!("✅ Zero Overhead:");
    println!("   • Compiles to same code as manual loops");
    println!("   • No runtime cost for abstraction");
    println!("   • Pay only for what you use\n");

    println!("✓ Lazy evaluation demo complete!\n");
}

examples/custom_queryable.rs (line 399)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Custom Queryable Implementation Demo                         ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // ============================================================================
    // DEMO 1: PaginatedCollection
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 1: PaginatedCollection (custom container)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut paginated = PaginatedCollection::new(3); // 3 items per page
    
    paginated.add(create_sample_product(1, "Laptop", 999.0, "Electronics", true));
    paginated.add(create_sample_product(2, "Mouse", 29.0, "Electronics", true));
    paginated.add(create_sample_product(3, "Keyboard", 129.0, "Electronics", true));
    paginated.add(create_sample_product(4, "Desk", 299.0, "Furniture", true));
    paginated.add(create_sample_product(5, "Chair", 199.0, "Furniture", false));

    println!("  Created paginated collection:");
    println!("    Total items: {}", paginated.total_items());
    println!("    Pages: {}", paginated.pages.len());

    // Now we can query it using the Queryable trait!
    // Collect to owned Vec for querying
    let items: Vec<Product> = paginated.query_iter().cloned().collect();
    let query = Query::new(&items)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query.all();
    
    println!("\n  Querying paginated collection:");
    println!("    Electronics found: {}", electronics.len());
    for product in electronics {
        println!("      • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // DEMO 2: CircularBuffer
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 2: CircularBuffer (fixed capacity)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut circular = CircularBuffer::new(3); // Capacity: 3
    
    circular.push(create_sample_product(1, "Product 1", 100.0, "A", true));
    circular.push(create_sample_product(2, "Product 2", 200.0, "B", true));
    circular.push(create_sample_product(3, "Product 3", 300.0, "C", true));
    circular.push(create_sample_product(4, "Product 4", 400.0, "D", true)); // Pushes out Product 1

    println!("  Circular buffer (capacity 3, added 4 items):");
    println!("    Current size: {}", circular.len());

    // Query the circular buffer
    let circ_items: Vec<Product> = circular.query_iter().cloned().collect();
    let circ_query = Query::new(&circ_items);
    let avg_price = circ_query.avg(Product::price_r()).unwrap_or(0.0);
    
    println!("\n  Querying circular buffer:");
    println!("    Average price: ${:.2}", avg_price);
    println!("    Items:");
    for (i, product) in circ_items.iter().enumerate() {
        println!("      {}. {}: ${:.2}", i + 1, product.name, product.price);
    }

    // ============================================================================
    // DEMO 3: FilteredStorage
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 3: FilteredStorage (auto-filtering container)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut filtered = FilteredStorage::new(|p: &Product| p.price < 200.0);
    
    println!("  FilteredStorage (only accepts items < $200):");
    println!("    Adding Laptop ($999): {}", filtered.add(create_sample_product(1, "Laptop", 999.0, "Electronics", true)));
    println!("    Adding Mouse ($29): {}", filtered.add(create_sample_product(2, "Mouse", 29.0, "Electronics", true)));
    println!("    Adding Keyboard ($129): {}", filtered.add(create_sample_product(3, "Keyboard", 129.0, "Electronics", true)));
    println!("    Total stored: {}", filtered.len());

    // Query the filtered storage
    let filt_items: Vec<Product> = filtered.query_iter().cloned().collect();
    let filt_query = Query::new(&filt_items)
        .where_(Product::in_stock_r(), |&v| v);
    let in_stock = filt_query.all();
    
    println!("\n  Querying filtered storage:");
    println!("    In stock items: {}", in_stock.len());

    // ============================================================================
    // DEMO 4: CategoryIndex
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 4: CategoryIndex (indexed by category)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut category_index = CategoryIndex::new();
    
    category_index.add("Electronics".to_string(), create_sample_product(1, "Monitor", 349.0, "Electronics", true));
    category_index.add("Electronics".to_string(), create_sample_product(2, "Webcam", 79.0, "Electronics", true));
    category_index.add("Furniture".to_string(), create_sample_product(3, "Desk", 299.0, "Furniture", true));
    category_index.add("Furniture".to_string(), create_sample_product(4, "Lamp", 39.0, "Furniture", true));

    println!("  CategoryIndex:");
    println!("    Categories: {:?}", category_index.categories());
    println!("    Total items: {}", category_index.total_items());

    // Query across all categories
    let idx_items: Vec<Product> = category_index.query_iter().cloned().collect();
    let idx_query = Query::new(&idx_items);
    let expensive = idx_query
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive_items = expensive.all();
    
    println!("\n  Querying category index:");
    println!("    Expensive items (>$100): {}", expensive_items.len());
    for product in expensive_items {
        println!("      • {}: ${:.2} ({})", product.name, product.price, product.category);
    }

    // ============================================================================
    // DEMO 5: LazyLoader
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 5: LazyLoader (simulated lazy loading)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let loader = LazyLoader::new(vec![
        create_sample_product(1, "Item 1", 50.0, "A", true),
        create_sample_product(2, "Item 2", 150.0, "B", true),
        create_sample_product(3, "Item 3", 250.0, "C", true),
    ]);

    println!("  LazyLoader:");
    println!("    Total available: {}", loader.total_count());
    println!("    Currently loaded: {}", loader.loaded_count());

    // Query loaded items
    let loader_items: Vec<Product> = loader.query_iter().cloned().collect();
    let loader_query = Query::new(&loader_items);
    let total_value = loader_query.sum(Product::price_r());
    
    println!("\n  Querying lazy loader:");
    println!("    Total value: ${:.2}", total_value);

    // ============================================================================
    // DEMO 6: Custom Container with LazyQuery
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 6: Using LazyQuery with custom containers");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut circular = CircularBuffer::new(5);
    for i in 1..=10 {
        circular.push(create_sample_product(
            i,
            &format!("Product {}", i),
            i as f64 * 50.0,
            if i % 2 == 0 { "Even" } else { "Odd" },
            true,
        ));
    }

    println!("  Circular buffer (capacity 5, added 10 items):");
    println!("    Current size: {}", circular.len());

    // Use LazyQuery for early termination!
    let circ_vec: Vec<Product> = circular.query_iter().cloned().collect();
    let first_expensive = LazyQuery::new(&circ_vec)
        .where_(Product::price_r(), |&p| p > 300.0)
        .first();

    if let Some(product) = first_expensive {
        println!("\n  First expensive item (lazy query):");
        println!("    {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // DEMO 7: Implementing Queryable for Wrapper Types
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 7: Queryable for wrapper types");
    println!("═══════════════════════════════════════════════════════════════\n");

    /// A simple wrapper around Vec with metadata
    struct VersionedCollection<T> {
        items: Vec<T>,
        version: u32,
        last_modified: String,
    }

    impl<T> Queryable<T> for VersionedCollection<T> {
        fn query_iter(&self) -> Box<dyn Iterator<Item = &T> + '_> {
            Box::new(self.items.iter())
        }
    }

    let versioned = VersionedCollection {
        items: vec![
            create_sample_product(1, "V1 Product", 99.0, "Test", true),
            create_sample_product(2, "V2 Product", 199.0, "Test", true),
        ],
        version: 2,
        last_modified: "2025-10-11".to_string(),
    };

    println!("  VersionedCollection:");
    println!("    Version: {}", versioned.version);
    println!("    Last modified: {}", versioned.last_modified);

    let versioned_items: Vec<Product> = versioned.query_iter().cloned().collect();
    let query = Query::new(&versioned_items);
    println!("    Items: {}", query.count());

    // ============================================================================
    // DEMO 8: Real-World Example - Cache with TTL
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 8: Cache container (real-world example)");
    println!("═══════════════════════════════════════════════════════════════\n");

    use std::time::{Duration, SystemTime};

    struct CachedItem<T> {
        item: T,
        inserted_at: SystemTime,
        ttl: Duration,
    }

    struct Cache<T> {
        items: Vec<CachedItem<T>>,
    }

    impl<T> Cache<T> {
        fn new() -> Self {
            Self { items: Vec::new() }
        }

        fn insert(&mut self, item: T, ttl: Duration) {
            self.items.push(CachedItem {
                item,
                inserted_at: SystemTime::now(),
                ttl,
            });
        }

        fn valid_items(&self) -> Vec<&T> {
            let now = SystemTime::now();
            self.items
                .iter()
                .filter(|cached| {
                    now.duration_since(cached.inserted_at)
                        .map_or(false, |elapsed| elapsed < cached.ttl)
                })
                .map(|cached| &cached.item)
                .collect()
        }
    }

    // Implement Queryable to query only valid (non-expired) items
    impl<T> Queryable<T> for Cache<T> {
        fn query_iter(&self) -> Box<dyn Iterator<Item = &T> + '_> {
            let now = SystemTime::now();
            Box::new(
                self.items
                    .iter()
                    .filter(move |cached| {
                        now.duration_since(cached.inserted_at)
                            .map_or(false, |elapsed| elapsed < cached.ttl)
                    })
                    .map(|cached| &cached.item),
            )
        }
    }

    let mut cache = Cache::new();
    cache.insert(create_sample_product(1, "Cached Item 1", 100.0, "A", true), Duration::from_secs(60));
    cache.insert(create_sample_product(2, "Cached Item 2", 200.0, "B", true), Duration::from_secs(60));

    let valid = cache.valid_items();
    println!("  Cache:");
    println!("    Total items: {}", cache.items.len());
    println!("    Valid items: {}", valid.len());

    // Query the cache
    let cache_items: Vec<Product> = cache.query_iter().cloned().collect();
    let cache_query = Query::new(&cache_items);
    println!("    Queryable items: {}", cache_query.count());

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: Implementing Queryable                              ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ How to make any container queryable:\n");
    println!("  1. Implement the Queryable<T> trait:");
    println!("     ```rust");
    println!("     impl<T> Queryable<T> for MyContainer<T> {{");
    println!("         fn query_iter(&self) -> Box<dyn Iterator<Item = &T> + '_> {{");
    println!("             Box::new(self.items.iter())");
    println!("         }}");
    println!("     }}");
    println!("     ```\n");

    println!("  2. Convert to Vec or slice for querying:");
    println!("     ```rust");
    println!("     let items: Vec<&Product> = container.query_iter().collect();");
    println!("     let query = Query::new(&items);");
    println!("     ```\n");

    println!("  3. Now use all query operations:");
    println!("     ```rust");
    println!("     let results = query.where_(...).all();");
    println!("     let count = query.count();");
    println!("     let total = query.sum(field);");
    println!("     ```\n");

    println!("📝 Custom containers demonstrated:");
    println!("   • PaginatedCollection - Items stored in pages");
    println!("   • CircularBuffer - Fixed-capacity FIFO buffer");
    println!("   • FilteredStorage - Auto-filtering container");
    println!("   • CategoryIndex - Indexed by category");
    println!("   • LazyLoader - Simulated lazy loading");
    println!("   • VersionedCollection - Wrapper with metadata");
    println!("   • Cache - TTL-based cache\n");

    println!("💡 Use cases:");
    println!("   • Database result wrappers");
    println!("   • Custom data structures");
    println!("   • Specialized collections");
    println!("   • Caches and buffers");
    println!("   • Event streams");
    println!("   • Any container that holds items!\n");

    println!("✓ Custom Queryable demo complete!\n");
}

examples/macro_helpers.rs (line 325)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Macro Helpers Demo - Reducing Boilerplate                    ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    let products = create_products();

    // ============================================================================
    // EXAMPLE 1: Simple Collection
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 1: collect_lazy! - Simple collection");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let results: Vec<_> = LazyQuery::new(&products).collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let results = collect_lazy!(&products);");
    println!("```\n");

    let results = collect_lazy!(&products);
    println!("Result: {} products collected\n", results.len());

    // ============================================================================
    // EXAMPLE 2: Filter and Collect
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 2: filter_collect! - Filter and collect");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let electronics: Vec<_> = LazyQuery::new(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Electronics\")");
    println!("    .collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let electronics = filter_collect!(");
    println!("    &products,");
    println!("    Product::category_r(),");
    println!("    |cat| cat == \"Electronics\"");
    println!(");");
    println!("```\n");

    let electronics = filter_collect!(
        &products,
        Product::category_r(),
        |cat| cat == "Electronics"
    );
    println!("Result: {} electronics\n", electronics.len());

    // ============================================================================
    // EXAMPLE 3: Count with Filter
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 3: count_where! - Count with filter");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let count = LazyQuery::new(&products)");
    println!("    .where_(Product::stock_r(), |&s| s > 0)");
    println!("    .count();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let count = count_where!(&products, Product::stock_r(), |&s| s > 0);");
    println!("```\n");

    let count = count_where!(&products, Product::stock_r(), |&s| s > 0);
    println!("Result: {} products in stock\n", count);

    // ============================================================================
    // EXAMPLE 4: Find First
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 4: find_first! - Find first matching item");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let found = LazyQuery::new(&products)");
    println!("    .where_(Product::price_r(), |&p| p > 500.0)");
    println!("    .first();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let found = find_first!(&products, Product::price_r(), |&p| p > 500.0);");
    println!("```\n");

    let found = find_first!(&products, Product::price_r(), |&p| p > 500.0);
    if let Some(p) = found {
        println!("Result: Found {} at ${:.2}\n", p.name, p.price);
    }

    // ============================================================================
    // EXAMPLE 5: Existence Check
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 5: exists_where! - Check if any item matches");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let has_furniture = LazyQuery::new(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Furniture\")");
    println!("    .any();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let has_furniture = exists_where!(");
    println!("    &products,");
    println!("    Product::category_r(),");
    println!("    |cat| cat == \"Furniture\"");
    println!(");");
    println!("```\n");

    let has_furniture = exists_where!(
        &products,
        Product::category_r(),
        |cat| cat == "Furniture"
    );
    println!("Result: Has furniture = {}\n", has_furniture);

    // ============================================================================
    // EXAMPLE 6: Pagination
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 6: paginate! - Quick pagination");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let page_2: Vec<_> = LazyQuery::new(&products)");
    println!("    .skip_lazy(1 * 2)  // page * size");
    println!("    .take_lazy(2)");
    println!("    .collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let page_2 = paginate!(&products, page: 1, size: 2);");
    println!("```\n");

    let page_2 = paginate!(&products, page: 1, size: 2);
    println!("Result: Page 2 has {} items\n", page_2.len());

    // ============================================================================
    // EXAMPLE 7: Sum with Filter
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 7: sum_where! - Sum with filter");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let total: f64 = LazyQuery::new(&products)");
    println!("    .where_(Product::active_r(), |&a| a)");
    println!("    .sum_by(Product::price_r());");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let total = sum_where!(&products, Product::price_r(), Product::active_r(), |&a| a);");
    println!("```\n");

    let total = sum_where!(&products, Product::price_r(), Product::active_r(), |&a| a);
    println!("Result: Total active products value = ${:.2}\n", total);

    // ============================================================================
    // EXAMPLE 8: Average with Filter
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 8: avg_where! - Average with filter");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let avg = LazyQuery::new(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Electronics\")");
    println!("    .avg_by(Product::price_r())");
    println!("    .unwrap_or(0.0);");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let avg = avg_where!(");
    println!("    &products,");
    println!("    Product::price_r(),");
    println!("    Product::category_r(),");
    println!("    |cat| cat == \"Electronics\"");
    println!(").unwrap_or(0.0);");
    println!("```\n");

    let avg = avg_where!(
        &products,
        Product::price_r(),
        Product::category_r(),
        |cat| cat == "Electronics"
    ).unwrap_or(0.0);
    println!("Result: Average electronics price = ${:.2}\n", avg);

    // ============================================================================
    // EXAMPLE 9: Select All
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 9: select_all! - Select field from all items");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let names: Vec<String> = LazyQuery::new(&products)");
    println!("    .select_lazy(Product::name_r())");
    println!("    .collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let names = select_all!(&products, Product::name_r());");
    println!("```\n");

    let names: Vec<String> = select_all!(&products, Product::name_r());
    println!("Result: {} product names\n", names.len());

    // ============================================================================
    // EXAMPLE 10: Select with Filter
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 10: select_where! - Select field with filter");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let furniture_names: Vec<String> = LazyQuery::new(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Furniture\")");
    println!("    .select_lazy(Product::name_r())");
    println!("    .collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let furniture_names = select_where!(");
    println!("    &products,");
    println!("    Product::name_r(),");
    println!("    Product::category_r(),");
    println!("    |cat| cat == \"Furniture\"");
    println!(");");
    println!("```\n");

    let furniture_names: Vec<String> = select_where!(
        &products,
        Product::name_r(),
        Product::category_r(),
        |cat| cat == "Furniture"
    );
    println!("Result: {} furniture items\n", furniture_names.len());

    // ============================================================================
    // COMPARISON: Complex Query
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Before & After");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Filter electronics, under $500, in stock, get first 5\n");

    println!("❌ WITHOUT MACROS (13 lines):");
    println!("```rust");
    println!("let results: Vec<_> = LazyQuery::new(&products)");
    println!("    .where_(");
    println!("        Product::category_r(),");
    println!("        |cat| cat == \"Electronics\"");
    println!("    )");
    println!("    .where_(Product::price_r(), |&p| p < 500.0)");
    println!("    .where_(Product::stock_r(), |&s| s > 0)");
    println!("    .take_lazy(5)");
    println!("    .collect();");
    println!("```\n");

    // Actual verbose version
    let verbose_results: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .where_(Product::stock_r(), |&s| s > 0)
        .take_lazy(5)
        .collect();

    println!("✅ WITH MACROS (Shorter, but still need multiple filters):");
    println!("```rust");
    println!("let results = lazy_query!(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Electronics\")");
    println!("    .where_(Product::price_r(), |&p| p < 500.0)");
    println!("    .where_(Product::stock_r(), |&s| s > 0)");
    println!("    .take_lazy(5)");
    println!("    .collect();");
    println!("```\n");

    let macro_results = lazy_query!(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .where_(Product::stock_r(), |&s| s > 0)
        .take_lazy(5)
        .collect();

    println!("Both approaches found {} items ✅\n", verbose_results.len());
    assert_eq!(verbose_results.len(), macro_results.len());

    // ============================================================================
    // CODE REDUCTION METRICS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Code Reduction Metrics");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Pattern Comparisons:\n");

    println!("  1. Simple collect:");
    println!("     Before: LazyQuery::new(&data).collect()");
    println!("     After:  collect_lazy!(&data)");
    println!("     Saved:  ~20 characters\n");

    println!("  2. Filter + collect:");
    println!("     Before: LazyQuery::new(&data).where_(...).collect()");
    println!("     After:  filter_collect!(&data, field, pred)");
    println!("     Saved:  ~35 characters\n");

    println!("  3. Count with filter:");
    println!("     Before: LazyQuery::new(&data).where_(...).count()");
    println!("     After:  count_where!(&data, field, pred)");
    println!("     Saved:  ~30 characters\n");

    println!("  4. Pagination:");
    println!("     Before: LazyQuery::new(&data).skip_lazy(p*s).take_lazy(s).collect()");
    println!("     After:  paginate!(&data, page: p, size: s)");
    println!("     Saved:  ~45 characters\n");

    println!("  5. Sum with filter:");
    println!("     Before: LazyQuery::new(&data).where_(...).sum_by(...)");
    println!("     After:  sum_where!(&data, sum_field, filter_field, pred)");
    println!("     Saved:  ~25 characters\n");

    // ============================================================================
    // ALL MACRO DEMONSTRATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("All Available Macros - Quick Reference");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("1. lazy_query!(&data)");
    let _q1 = lazy_query!(&products);
    println!("   → LazyQuery::new(&data)\n");

    println!("2. query!(&data)");
    let _q2 = query!(&products);
    println!("   → Query::new(&data)\n");

    println!("3. collect_lazy!(&data)");
    let _r3 = collect_lazy!(&products);
    println!("   → LazyQuery::new(&data).collect()\n");

    println!("4. filter_collect!(&data, field, pred)");
    let _r4 = filter_collect!(&products, Product::active_r(), |&a| a);
    println!("   → LazyQuery::new(&data).where_(field, pred).collect()\n");

    println!("5. count_where!(&data, field, pred)");
    let _r5 = count_where!(&products, Product::active_r(), |&a| a);
    println!("   → LazyQuery::new(&data).where_(field, pred).count()\n");

    println!("6. find_first!(&data, field, pred)");
    let _r6 = find_first!(&products, Product::id_r(), |&id| id == 1);
    println!("   → LazyQuery::new(&data).where_(field, pred).first()\n");

    println!("7. exists_where!(&data, field, pred)");
    let _r7 = exists_where!(&products, Product::active_r(), |&a| a);
    println!("   → LazyQuery::new(&data).where_(field, pred).any()\n");

    println!("8. paginate!(&data, page: p, size: s)");
    let _r8 = paginate!(&products, page: 0, size: 3);
    println!("   → LazyQuery::new(&data).skip_lazy(p*s).take_lazy(s).collect()\n");

    println!("9. sum_where!(&data, sum_field, filter_field, pred)");
    let _r9 = sum_where!(&products, Product::price_r(), Product::active_r(), |&a| a);
    println!("   → LazyQuery::new(&data).where_(filter_field, pred).sum_by(sum_field)\n");

    println!("10. avg_where!(&data, avg_field, filter_field, pred)");
    let _r10 = avg_where!(&products, Product::price_r(), Product::active_r(), |&a| a);
    println!("    → LazyQuery::new(&data).where_(filter_field, pred).avg_by(avg_field)\n");

    println!("11. select_all!(&data, field)");
    let _r11: Vec<String> = select_all!(&products, Product::name_r());
    println!("    → LazyQuery::new(&data).select_lazy(field).collect()\n");

    println!("12. select_where!(&data, select_field, filter_field, pred)");
    let _r12: Vec<String> = select_where!(&products, Product::name_r(), Product::active_r(), |&a| a);
    println!("    → LazyQuery::new(&data).where_(filter, pred).select_lazy(field).collect()\n");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("╔════════════════════════════════════════════════════════════════╗");
    println!("║  Summary                                                       ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ 12 helper macros provided:");
    println!("   • lazy_query! - Create LazyQuery");
    println!("   • query! - Create Query");
    println!("   • collect_lazy! - Quick collect");
    println!("   • filter_collect! - Filter and collect");
    println!("   • count_where! - Count with filter");
    println!("   • find_first! - Find first match");
    println!("   • exists_where! - Existence check");
    println!("   • paginate! - Easy pagination");
    println!("   • sum_where! - Sum with filter");
    println!("   • avg_where! - Average with filter");
    println!("   • select_all! - Select all");
    println!("   • select_where! - Select with filter\n");

    println!("📊 Benefits:");
    println!("   • Less typing (20-45 characters saved per operation)");
    println!("   • More readable code");
    println!("   • Common patterns encapsulated");
    println!("   • Same performance (zero-cost abstraction)");
    println!("   • Type-safe (compile-time checked)\n");

    println!("💡 When to use:");
    println!("   • Use macros for simple, common patterns");
    println!("   • Use full API for complex queries");
    println!("   • Mix and match as needed\n");

    println!("✓ Macro helpers demo complete!\n");
}

examples/arc_rwlock_hashmap.rs (line 82)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Arc<RwLock<T>> HashMap Lazy Query Demo                         ║");
    println!("║  Thread-safe shared data with lazy evaluation                   ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    let product_map = create_sample_data();
    println!("Created product catalog:");
    println!("  Total products: {}", product_map.len());
    println!("  Keys: {:?}\n", product_map.keys().take(3).collect::<Vec<_>>());

    // Extract products for querying
    let products = extract_products(&product_map);
    println!("Extracted {} products from Arc<RwLock<Product>>\n", products.len());

    // ============================================================================
    // LAZY OPERATION 1: where_ - Lazy Filtering
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 1: where_ (filtering)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building filtered query (nothing executes yet)...");
    let electronics_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::active_r(), |&active| active)
        .where_(Product::stock_r(), |&stock| stock > 20);

    println!("  ✅ Query built (deferred execution)\n");

    println!("Collecting results (executes now)...");
    let electronics: Vec<_> = electronics_query.collect();
    println!("  Found {} electronics in stock", electronics.len());
    for p in &electronics {
        println!("    • {}: {} in stock", p.name, p.stock);
    }

    // ============================================================================
    // LAZY OPERATION 2: select_lazy - Lazy Projection
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 2: select_lazy (projection)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting product names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .select_lazy(Product::name_r())
        .collect();

    println!("  Furniture names ({}):", names.len());
    for name in &names {
        println!("    • {}", name);
    }

    // ============================================================================
    // LAZY OPERATION 3: take_lazy - Early Termination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 3: take_lazy (early termination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting first 3 electronics...");
    let first_3: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
        .collect();

    println!("  First 3 electronics:");
    for (i, p) in first_3.iter().enumerate() {
        println!("    {}. {} - ${:.2}", i + 1, p.name, p.price);
    }
    println!("  ✅ Stopped after finding 3 items!");

    // ============================================================================
    // LAZY OPERATION 4: skip_lazy - Pagination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 4: skip_lazy (pagination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting page 2 (skip 3, take 3)...");
    let page_2: Vec<_> = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .skip_lazy(3)
        .take_lazy(3)
        .collect();

    println!("  Page 2 items:");
    for (i, p) in page_2.iter().enumerate() {
        println!("    {}. {}", i + 4, p.name);
    }

    // ============================================================================
    // LAZY OPERATION 5: first - Short-Circuit Search
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 5: first (short-circuit)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Finding first expensive item (>$1000)...");
    let expensive = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0)
        .first();

    match expensive {
        Some(p) => println!("  Found: {} - ${:.2}", p.name, p.price),
        None => println!("  Not found"),
    }
    println!("  ✅ Stopped at first match!");

    // ============================================================================
    // LAZY OPERATION 6: any - Existence Check
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 6: any (existence check)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Checking if any furniture exists...");
    let has_furniture = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .any();

    println!("  Has furniture: {}", has_furniture);
    println!("  ✅ Stopped immediately after finding first match!");

    // ============================================================================
    // LAZY OPERATION 7: count - Count Matching Items
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 7: count");
    println!("═══════════════════════════════════════════════════════════════\n");

    let electronics_count = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .count();

    println!("  Electronics count: {}", electronics_count);

    // ============================================================================
    // LAZY OPERATION 8: sum_by - Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 8: sum_by (aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_value: f64 = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .sum_by(Product::price_r());

    println!("  Total electronics value: ${:.2}", total_value);

    // ============================================================================
    // LAZY OPERATION 9: avg_by - Average
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 9: avg_by");
    println!("═══════════════════════════════════════════════════════════════\n");

    let avg_price = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .avg_by(Product::price_r())
        .unwrap_or(0.0);

    println!("  Average furniture price: ${:.2}", avg_price);

    // ============================================================================
    // LAZY OPERATION 10: min_by_float / max_by_float
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 10: min_by_float / max_by_float");
    println!("═══════════════════════════════════════════════════════════════\n");

    let min_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .min_by_float(Product::price_r())
        .unwrap_or(0.0);

    let max_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .max_by_float(Product::price_r())
        .unwrap_or(0.0);

    println!("  Price range for active products:");
    println!("    Min: ${:.2}", min_price);
    println!("    Max: ${:.2}", max_price);

    // ============================================================================
    // LAZY OPERATION 11: find - Find with Predicate
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 11: find (with predicate)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let high_rated = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .find(|item| item.rating > 4.7);

    if let Some(product) = high_rated {
        println!("  First highly-rated electronic:");
        println!("    {}: Rating {:.1}", product.name, product.rating);
    }

    // ============================================================================
    // LAZY OPERATION 12: for_each - Iteration
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 12: for_each (iteration)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  Low stock alerts:");
    LazyQuery::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .for_each(|product| {
            println!("    ⚠️  {}: Only {} in stock", product.name, product.stock);
        });

    // ============================================================================
    // LAZY OPERATION 13: fold - Custom Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 14: fold (custom aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_inventory_value = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .fold(0.0, |acc, product| {
            acc + (product.price * product.stock as f64)
        });

    println!("  Total inventory value: ${:.2}", total_inventory_value);

    // ============================================================================
    // LAZY OPERATION 14: all_match - Validation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 15: all_match (validation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let all_priced = LazyQuery::new(&products)
        .all_match(|item| item.price > 0.0);

    println!("  All products have valid prices: {}", all_priced);

    // ============================================================================
    // LAZY OPERATION 15: into_iter - For Loop
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 16: into_iter (for loop)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  High-value products (>$300):");
    for product in LazyQuery::new(&products)
        .where_(Product::price_r(), |&p| p > 300.0)
        .take_lazy(5)
    {
        println!("    • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // LAZY OPERATION 16: map_items - Transform
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 17: map_items (transformation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let price_tags: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .map_items(|p| format!("{}: ${:.2}", p.name, p.price))
        .take(5)
        .collect();

    println!("  Electronics price tags:");
    for tag in &price_tags {
        println!("    • {}", tag);
    }

    // ============================================================================
    // COMPLEX EXAMPLE: Multi-Stage Lazy Pipeline
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Multi-stage lazy pipeline");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building complex query:");
    println!("  1. Filter by category (Electronics)");
    println!("  2. Filter by price range ($50-$500)");
    println!("  3. Filter by rating (>4.5)");
    println!("  4. Select names");
    println!("  5. Take first 3");
    println!();

    let results: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p >= 50.0 && p <= 500.0)
        .where_(Product::rating_r(), |&r| r > 4.5)
        .select_lazy(Product::name_r())
        .take(3)
        .collect();

    println!("  Results:");
    for (i, name) in results.iter().enumerate() {
        println!("    {}. {}", i + 1, name);
    }
    println!("  ✅ All operations fused and executed lazily!");

    // ============================================================================
    // THREAD-SAFE UPDATES WITH RWLOCK
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Bonus: Thread-safe updates with RwLock");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Update a product through the Arc<RwLock>
    if let Some(product_arc) = product_map.get("PROD-002") {
        println!("Updating PROD-002 stock...");
        
        // Write lock for mutation
        if let Ok(mut product) = product_arc.write() {
            let old_stock = product.stock;
            product.stock = 25;
            println!("  Stock updated: {} → {}", old_stock, product.stock);
        }
    }

    // Query again to see the update
    let updated_products = extract_products(&product_map);
    let mouse = LazyQuery::new(&updated_products)
        .find(|p| p.id == 2);

    if let Some(product) = mouse {
        println!("  Verified update: {} now has {} in stock", product.name, product.stock);
    }

    // ============================================================================
    // PRACTICAL EXAMPLE: Price Analysis by Category
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Practical Example: Price analysis by category");
    println!("═══════════════════════════════════════════════════════════════\n");

    let categories = vec!["Electronics", "Furniture"];

    for category in categories {
        println!("  {} Statistics:", category);
        
        // Filter products by category first
        let cat_products: Vec<Product> = products.iter()
            .filter(|p| p.category == category)
            .cloned()
            .collect();

        let count = LazyQuery::new(&cat_products).count();
        let total = LazyQuery::new(&cat_products).sum_by(Product::price_r());
        let avg = LazyQuery::new(&cat_products).avg_by(Product::price_r()).unwrap_or(0.0);
        let min = LazyQuery::new(&cat_products).min_by_float(Product::price_r()).unwrap_or(0.0);
        let max = LazyQuery::new(&cat_products).max_by_float(Product::price_r()).unwrap_or(0.0);

        println!("    Count: {}", count);
        println!("    Total: ${:.2}", total);
        println!("    Average: ${:.2}", avg);
        println!("    Range: ${:.2} - ${:.2}\n", min, max);
    }

    // ============================================================================
    // COMBINING WITH HASHMAP OPERATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("HashMap Integration: Query by key patterns");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Filter HashMap by key pattern
    let electronics_keys: Vec<String> = product_map
        .iter()
        .filter(|(_key, value)| {
            // Read the value to check category
            if let Ok(guard) = value.read() {
                guard.category == "Electronics"
            } else {
                false
            }
        })
        .map(|(key, _value)| key.clone())
        .collect();

    println!("  Electronics product IDs:");
    for key in electronics_keys.iter().take(5) {
        println!("    • {}", key);
    }

    // ============================================================================
    // PERFORMANCE DEMONSTRATION
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Performance: Lazy vs Eager comparison");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first product with rating > 4.7 from {} products\n", products.len());

    println!("  Eager approach (hypothetical):");
    println!("    - Filter all {} products", products.len());
    println!("    - Collect filtered results");
    println!("    - Take first item");
    println!("    - Wasted work: Check all items\n");

    println!("  Lazy approach (actual):");
    let _first_rated = LazyQuery::new(&products)
        .where_(Product::rating_r(), |&r| r > 4.7)
        .first();
    println!("    - Starts checking products");
    println!("    - Stops at first match");
    println!("    - ✅ Early termination - checks ~3-5 items only!");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: All Lazy Operations Demonstrated                      ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Lazy Query Operations:");
    println!("   1. ✅ where_ - Lazy filtering");
    println!("   2. ✅ select_lazy - Lazy projection");
    println!("   3. ✅ take_lazy - Early termination");
    println!("   4. ✅ skip_lazy - Pagination");
    println!("   5. ✅ first - Short-circuit search");
    println!("   6. ✅ any - Existence check (short-circuit)");
    println!("   7. ✅ count - Count items");
    println!("   8. ✅ sum_by - Sum aggregation");
    println!("   9. ✅ avg_by - Average aggregation");
    println!("   10. ✅ min_by_float - Minimum value");
    println!("   11. ✅ max_by_float - Maximum value");
    println!("   12. ✅ find - Find with predicate (short-circuit)");
    println!("   13. ✅ for_each - Iteration");
    println!("   14. ✅ fold - Custom aggregation");
    println!("   15. ✅ all_match - Validation (short-circuit)");
    println!("   16. ✅ into_iter - For loop support");
    println!("   17. ✅ map_items - Transformation\n");

    println!("✅ Arc<RwLock<T>> Benefits:");
    println!("   • Thread-safe shared access");
    println!("   • Interior mutability");
    println!("   • Multiple readers, single writer");
    println!("   • Reference counting (Arc)");
    println!("   • Can be queried after extracting data\n");

    println!("✅ HashMap<K, Arc<RwLock<V>>> Benefits:");
    println!("   • Fast key-based lookup");
    println!("   • Thread-safe value access");
    println!("   • Can query all values");
    println!("   • Can filter by key patterns");
    println!("   • Perfect for shared state/caches\n");

    println!("🎯 Use Cases:");
    println!("   • Shared product catalogs");
    println!("   • User session stores");
    println!("   • Configuration caches");
    println!("   • Real-time inventory systems");
    println!("   • Multi-threaded data processing");
    println!("   • Web server state management\n");

    println!("✓ Arc<RwLock<T>> HashMap with all lazy operations demo complete!\n");
}

impl<'a, T, I> LazyQuery<'a, T, I>

where T: 'static, I: Iterator<Item = &'a T> + 'a,

pub fn where_<F, P>( self, path: KeyPaths<T, F>, predicate: P, ) -> LazyQuery<'a, T, impl Iterator<Item = &'a T> + 'a>

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

Adds a filter predicate (lazy - not executed yet).

Example

let query = LazyQuery::new(&products)
    .where_(Product::price_r(), |&p| p < 100.0);

Examples found in repository

examples/individual_crates.rs (line 102)

fn main() {
    println!("Individual Crates Example");
    println!("=========================\n");
    println!("Using rust-queries-core + rust-queries-derive directly\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. QueryExt from rust_queries_core");
    println!("   products.query().where_(price > 100).all()");
    
    let query = products
        .query()  // From QueryExt trait
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. QueryBuilder from rust_queries_derive");
    println!("   Product::query(&products).where_(stock < 10).all()");
    
    let query2 = Product::query(&products)  // From QueryBuilder derive
        .where_(Product::stock_r(), |&s| s < 10);
    let low_stock = query2.all();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. LazyQuery from rust_queries_core");
    println!("   products.lazy_query().where_(...).collect()");
    
    let electronics: Vec<_> = products
        .lazy_query()  // From QueryExt trait
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .collect();
    
    println!("   Found {} electronics:", electronics.len());
    for product in electronics {
        println!("   - {}", product.name);
    }
    println!();

    println!("4. Aggregations with LazyQuery");
    println!("   products.lazy_query().sum_by(Product::price_r())");
    
    let total_value: f64 = products
        .lazy_query()
        .sum_by(Product::price_r());
    
    println!("   Total inventory value: ${:.2}", total_value);
    println!();

    println!("5. Early termination with lazy queries");
    println!("   products.lazy_query().where_(...).first()");
    
    if let Some(first_cheap) = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p < 50.0)
        .first()
    {
        println!("   First cheap product: {} (${:.2})", first_cheap.name, first_cheap.price);
    }
    println!();

    println!("6. Using Query (eager) from rust_queries_core");
    println!("   Query::new(&products).where_(...).count()");
    
    let query3 = Query::new(&products)  // Traditional approach
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query3.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ rust_queries_core provides: Query, LazyQuery, QueryExt");
    println!("✓ rust_queries_derive provides: #[derive(QueryBuilder)]");
    println!("✓ key_paths_derive provides: #[derive(Keypaths)]");
    println!("✓ All features work with individual crates!");
}

examples/derive_and_ext.rs (line 74)

fn main() {
    println!("Derive Macros and Extension Traits Example");
    println!("===========================================\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. Using Extension Trait - Direct .query() on Vec");
    println!("   Query: products.query().where_(price > 100).all()");
    
    let query = products
        .query()
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in &expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. Using Extension Trait - Direct .lazy_query() on Vec");
    println!("   Query: products.lazy_query().where_(stock < 10).collect()");
    
    let low_stock: Vec<_> = products
        .lazy_query()
        .where_(Product::stock_r(), |&s| s < 10)
        .collect();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in &low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. Using Extension Trait - Chained Operations");
    println!("   Query: products.lazy_query().where_(category == Electronics).take(2).select(name).collect()");
    
    let names: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(2)
        .select_lazy(Product::name_r())
        .collect();
    
    println!("   First 2 electronics:");
    for name in &names {
        println!("   - {}", name);
    }
    println!();

    println!("4. Using QueryBuilder Derive - Static Methods");
    println!("   Query: Product::query(&products).where_(price > 50).count()");
    
    let query4 = Product::query(&products)
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query4.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("5. Using QueryBuilder Derive - Lazy Static Methods");
    println!("   Query: Product::lazy_query(&products).first()");
    
    if let Some(first) = Product::lazy_query(&products).first() {
        println!("   First product: {} (${:.2})", first.name, first.price);
    }
    println!();

    println!("6. Complex Chain with Extension Trait");
    println!("   Query: products.lazy_query()");
    println!("          .where_(category == Electronics)");
    println!("          .where_(price < 500)");
    println!("          .map(|p| format!(\"{{}} - ${{:.2}}\", p.name, p.price))");
    println!("          .collect()");
    
    let formatted: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .map_items(|p| format!("{} - ${:.2}", p.name, p.price))
        .collect();
    
    println!("   Affordable electronics:");
    for item in &formatted {
        println!("   - {}", item);
    }
    println!();

    println!("7. Aggregation with Extension Trait");
    println!("   Query: products.lazy_query().sum_by(Product::stock())");
    
    let total_stock = products
        .lazy_query()
        .sum_by(Product::stock_r());
    
    println!("   Total stock across all products: {}", total_stock);
    println!();

    println!("8. Find with Extension Trait");
    println!("   Query: products.lazy_query().find(|p| p.name.contains(\"Chair\"))");
    
    if let Some(chair) = products.lazy_query().find(|p| p.name.contains("Chair")) {
        println!("   Found: {} in {}", chair.name, chair.category);
    }
    println!();

    println!("9. Early Termination with Extension Trait");
    println!("   Query: products.lazy_query().where_(price > 1000).any()");
    
    let has_luxury = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p > 1000.0)
        .any();
    
    println!("   Has products over $1000: {}", has_luxury);
    println!();

    println!("10. Slice Extension Trait");
    println!("    Query: (&products[..]).lazy_query().count()");
    
    let slice_count = (&products[..])
        .lazy_query()
        .count();
    
    println!("    Count from slice: {}", slice_count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ Extension trait QueryExt adds .query() and .lazy_query() to containers");
    println!("✓ Derive macro QueryBuilder adds static methods Product::query() and Product::lazy_query()");
    println!("✓ Both approaches provide the same query functionality");
    println!("✓ Extension trait is more ergonomic: products.query() vs Query::new(&products)");
    println!("✓ All iterator optimizations (fusion, early termination) still apply");
}

examples/container_support.rs (line 53)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Container Support Demo                                       ║");
    println!("║  Query various collection types                               ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // ============================================================================
    // CONTAINER 1: Vec<T>
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Container 1: Vec<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let vec_products = vec![
        create_sample_product(1, "Laptop", 999, "Electronics"),
        create_sample_product(2, "Mouse", 29, "Electronics"),
        create_sample_product(3, "Desk", 299, "Furniture"),
    ];

    // Query Vec directly
    let vec_query = Query::new(&vec_products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let vec_results = vec_query.all();
    println!("  Vec: Found {} electronics", vec_results.len());

    // Lazy query on Vec
    let lazy_count = LazyQuery::new(&vec_products)
        .where_(Product::price_r(), |&p| p < 100)
        .count();
    println!("  Vec (lazy): {} items under $100", lazy_count);

    // ============================================================================
    // CONTAINER 2: VecDeque<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 2: VecDeque<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut deque_products = VecDeque::new();
    deque_products.push_back(create_sample_product(1, "Keyboard", 129, "Electronics"));
    deque_products.push_back(create_sample_product(2, "Monitor", 349, "Electronics"));
    deque_products.push_back(create_sample_product(3, "Chair", 199, "Furniture"));

    // Convert to owned Vec for querying
    let deque_vec: Vec<Product> = deque_products.iter().cloned().collect();
    let deque_query = Query::new(&deque_vec);
    let deque_count = deque_query.count();
    println!("  VecDeque: {} total items", deque_count);

    // More efficient: use make_contiguous for zero-copy slice access
    let contiguous = deque_products.make_contiguous();
    let contiguous_query = Query::new(contiguous);
    println!("  VecDeque (zero-copy): {} items", contiguous_query.count());

    // ============================================================================
    // CONTAINER 3: HashSet<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 3: HashSet<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut set_products = HashSet::new();
    set_products.insert(create_sample_product(1, "Tablet", 499, "Electronics"));
    set_products.insert(create_sample_product(2, "Phone", 799, "Electronics"));
    set_products.insert(create_sample_product(3, "Lamp", 39, "Furniture"));

    // Collect from HashSet to Vec for querying
    let set_vec: Vec<Product> = set_products.iter().cloned().collect();
    let set_query = Query::new(&set_vec)
        .where_(Product::price_r(), |&p| p > 500);
    let expensive = set_query.all();
    println!("  HashSet: {} expensive items", expensive.len());

    // Lazy on HashSet (convert to owned Vec first)
    let set_owned: Vec<Product> = set_products.iter().cloned().collect();
    let lazy_set: Vec<_> = LazyQuery::new(&set_owned)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .collect();
    println!("  HashSet (lazy): {} electronics", lazy_set.len());

    // ============================================================================
    // CONTAINER 4: BTreeSet<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 4: BTreeSet<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut btree_set = BTreeSet::new();
    btree_set.insert(create_sample_product(1, "Webcam", 79, "Electronics"));
    btree_set.insert(create_sample_product(2, "Microphone", 129, "Electronics"));
    btree_set.insert(create_sample_product(3, "Bookshelf", 149, "Furniture"));

    let btree_vec: Vec<Product> = btree_set.iter().cloned().collect();
    let btree_query = Query::new(&btree_vec);
    println!("  BTreeSet: {} total items (sorted order!)", btree_query.count());
    
    // BTreeSet items are in sorted order
    for (i, item) in btree_vec.iter().take(3).enumerate() {
        println!("    {}. {} (ID: {})", i + 1, item.name, item.id);
    }

    // ============================================================================
    // CONTAINER 5: HashMap<K, V> - Query Values
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 5: HashMap<K, V> - Querying values");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut map_products = HashMap::new();
    map_products.insert("prod1", create_sample_product(1, "Speaker", 199, "Electronics"));
    map_products.insert("prod2", create_sample_product(2, "Headphones", 149, "Electronics"));
    map_products.insert("prod3", create_sample_product(3, "Ottoman", 249, "Furniture"));

    // Query HashMap values (convert to owned Vec)
    let map_vec: Vec<Product> = map_products.values().cloned().collect();
    let map_query = Query::new(&map_vec)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = map_query.all();
    println!("  HashMap: {} electronics", electronics.len());

    // ============================================================================
    // CONTAINER 6: BTreeMap<K, V> - Query Values
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 6: BTreeMap<K, V> - Querying values");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut btree_map = BTreeMap::new();
    btree_map.insert(1, create_sample_product(1, "Router", 89, "Electronics"));
    btree_map.insert(2, create_sample_product(2, "Switch", 129, "Electronics"));
    btree_map.insert(3, create_sample_product(3, "Sofa", 899, "Furniture"));

    let btree_map_vec: Vec<Product> = btree_map.values().cloned().collect();
    let btree_map_query = Query::new(&btree_map_vec);
    let avg_price = btree_map_query.sum(Product::price_r()) as f64 / btree_map.len() as f64;
    println!("  BTreeMap: Average price ${:.2}", avg_price);

    // ============================================================================
    // CONTAINER 7: Arrays [T; N]
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 7: Arrays [T; N]");
    println!("═══════════════════════════════════════════════════════════════\n");

    let array_products = [
        create_sample_product(1, "USB Cable", 15, "Electronics"),
        create_sample_product(2, "HDMI Cable", 25, "Electronics"),
        create_sample_product(3, "Power Strip", 35, "Electronics"),
    ];

    // Query array directly (as slice)
    let array_query = Query::new(&array_products);
    let total = array_query.sum(Product::price_r());
    println!("  Array: Total value ${}", total);

    // Lazy on array
    let lazy_array: Vec<_> = LazyQuery::new(&array_products)
        .where_(Product::price_r(), |&p| p > 20)
        .collect();
    println!("  Array (lazy): {} items over $20", lazy_array.len());

    // ============================================================================
    // CONTAINER 8: LinkedList<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 8: LinkedList<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut list_products = LinkedList::new();
    list_products.push_back(create_sample_product(1, "SSD", 159, "Electronics"));
    list_products.push_back(create_sample_product(2, "HDD", 79, "Electronics"));

    let list_vec: Vec<Product> = list_products.iter().cloned().collect();
    let list_query = Query::new(&list_vec);
    println!("  LinkedList: {} items", list_query.count());

    // ============================================================================
    // CONTAINER 9: Option<T> and Result<T, E>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 9: Option<T> and Result<T, E>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let maybe_product = Some(create_sample_product(1, "Mystery Box", 99, "Special"));
    
    if let Some(ref product) = maybe_product {
        let option_query = Query::new(std::slice::from_ref(product));
        println!("  Option (Some): {} items", option_query.count());
    }

    let none_product: Option<Product> = None;
    let none_count = none_product.iter().count();
    println!("  Option (None): {} items", none_count);

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Supported Containers Summary                                  ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Supported container types:");
    println!("   • Vec<T>              - Standard vector");
    println!("   • &[T]                - Slices");
    println!("   • [T; N]              - Fixed-size arrays");
    println!("   • VecDeque<T>         - Double-ended queue");
    println!("   • LinkedList<T>       - Doubly-linked list");
    println!("   • HashSet<T>          - Unordered set");
    println!("   • BTreeSet<T>         - Ordered set");
    println!("   • HashMap<K, V>       - Query values");
    println!("   • BTreeMap<K, V>      - Query values (sorted)");
    println!("   • Option<T>           - 0 or 1 item");
    println!("   • Result<T, E>        - 0 or 1 item\n");

    println!("📝 Usage patterns:");
    println!("   • Direct: Query::new(&container) for Vec, slices, arrays");
    println!("   • Convert: Collect to Vec for Sets and Maps");
    println!("   • Lazy: LazyQuery::new(&slice) for any slice\n");

    println!("💡 Tips:");
    println!("   • Vec/slice: Direct support, most efficient");
    println!("   • Sets: Iterate to Vec, then query");
    println!("   • Maps: Use .values().collect() to query values");
    println!("   • VecDeque: Use .as_slices() for zero-copy");
    println!("   • For custom types: Implement Queryable trait\n");

    println!("✓ Container support demo complete!\n");
}

examples/lazy_evaluation.rs (lines 66-69)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Lazy Query Evaluation Demo                                   ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    let products = create_products();
    println!("Created {} products\n", products.len());

    // ============================================================================
    // DEMO 1: Lazy Execution - Nothing Happens Until .collect()
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 1: Lazy execution - deferred until needed");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Building query (should execute nothing)...");
    let lazy_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            cat == "Electronics"
        });

    let evals_after_build = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Filter evaluations after building query: {}", evals_after_build);
    
    if evals_after_build == 0 {
        println!("  ✅ Confirmed: Query is lazy! Nothing executed yet.\n");
    }

    println!("Collecting results (now it executes)...");
    let results: Vec<_> = lazy_query.collect();

    let evals_after_collect = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Filter evaluations after collecting: {}", evals_after_collect);
    println!("  Results found: {}", results.len());
    println!("  ✅ Query executed exactly once, when needed!\n");

    // ============================================================================
    // DEMO 2: Early Termination - Stops as Soon as Enough Items Found
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 2: Early termination with .take()");
    println!("═══════════════════════════════════════════════════════════════\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);

    println!("Finding first 5 expensive items from 1000 products...");
    let first_5: Vec<_> = LazyQuery::new(&products)
        .where_(Product::price_r(), |p| expensive_check(p))
        .take_lazy(5)
        .collect();

    let ops = EXPENSIVE_OPERATIONS.load(Ordering::SeqCst);
    println!("  Found: {} items", first_5.len());
    println!("  Expensive operations performed: {}", ops);
    println!("  Items NOT checked: {} (stopped early!)", 1000 - ops);
    
    if ops < 1000 {
        println!("  ✅ Early termination worked! Didn't check all 1000 items.\n");
    }

    // ============================================================================
    // DEMO 3: Iterator Fusion - Rust Optimizes Chained Operations
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 3: Iterator fusion - chained operations optimized");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Chaining multiple operations...");
    let chained_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price > 200.0)
        .where_(Product::stock_r(), |&stock| stock > 10)
        .take_lazy(10);

    println!("  Built query with 3 filters + take(10)");
    println!("  ✅ No execution yet - all operations fused into one iterator\n");

    let results: Vec<_> = chained_query.collect();
    println!("  Executed: Found {} items", results.len());
    println!("  ✅ All filters applied in single pass!\n");

    // ============================================================================
    // DEMO 4: Lazy Projection - Only Extract What You Need
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 4: Lazy projection");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .select_lazy(Product::name_r())
        .take(5)  // Only process until we have 5
        .collect();

    println!("  Selected {} names", names.len());
    println!("  ✅ Only evaluated until 5 names found!\n");

    // ============================================================================
    // DEMO 5: Lazy Aggregation - Short-Circuit When Possible
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 5: Short-circuit with .any()");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Checking if ANY electronics exist (1000 items to search)...");
    let exists = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            cat == "Electronics"
        })
        .any();

    let checks = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Result: {}", exists);
    println!("  Items checked: {} out of 1000", checks);
    println!("  Items skipped: {} (short-circuited!)", 1000 - checks);
    
    if checks < 1000 {
        println!("  ✅ Short-circuit worked! Stopped as soon as first match found.\n");
    }

    // ============================================================================
    // DEMO 6: Lazy Find - Stops at First Match
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 6: .find() stops at first match");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Finding first product with price > 500...");
    let found = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            price > 500.0
        })
        .first();

    let checks = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    if let Some(product) = found {
        println!("  Found: {} (${:.2})", product.name, product.price);
    }
    println!("  Items checked: {} out of 1000", checks);
    println!("  ✅ Stopped immediately after finding first match!\n");

    // ============================================================================
    // DEMO 7: Composition - Build Queries Incrementally
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 7: Composable queries");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building base query...");
    let base_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Created base query (not executed)\n");

    println!("  Adding price filter...");
    let refined_query = base_query
        .where_(Product::price_r(), |&price| price > 100.0);

    println!("  Still not executed...\n");

    println!("  Adding stock filter and limiting...");
    let final_query = refined_query
        .where_(Product::stock_r(), |&stock| stock > 5)
        .take_lazy(10);

    println!("  Still not executed...\n");

    println!("  Executing...");
    let results: Vec<_> = final_query.collect();
    println!("  ✅ Executed once with all filters: Found {} items\n", results.len());

    // ============================================================================
    // DEMO 8: For Loop - Natural Iteration
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 8: Use in for loops");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Iterating over filtered products...");
    let mut count = 0;
    for product in LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
    {
        println!("  • {}: ${:.2}", product.name, product.price);
        count += 1;
    }
    println!("  ✅ Processed {} items lazily\n", count);

    // ============================================================================
    // DEMO 9: Performance Comparison
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 9: Performance benefit demonstration");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first expensive item from 1000 products\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);
    
    println!("Without lazy (hypothetical - check all, then take first):");
    println!("  Would check: 1000 items");
    println!("  Would find: ~300 matching items");
    println!("  Would return: 1 item");
    println!("  Wasted work: 299 items processed unnecessarily\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);
    
    println!("With lazy evaluation:");
    let _first = LazyQuery::new(&products)
        .where_(Product::price_r(), |p| expensive_check(p))
        .first();

    let ops = EXPENSIVE_OPERATIONS.load(Ordering::SeqCst);
    println!("  Checked: {} items", ops);
    println!("  Found: 1 item");
    println!("  Wasted work: 0 items");
    println!("  ✅ Efficiency gain: {}x faster!", 1000 / ops.max(1));

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Lazy Evaluation Benefits                                     ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Deferred Execution:");
    println!("   • No work until results needed");
    println!("   • Can build complex queries without performance cost\n");

    println!("✅ Early Termination:");
    println!("   • .take(n) stops after n items");
    println!("   • .first() stops after 1 item");
    println!("   • .any() stops after first match");
    println!("   • Massive performance win for large datasets\n");

    println!("✅ Iterator Fusion:");
    println!("   • Multiple filters combined into one pass");
    println!("   • Rust compiler optimizes chained operations");
    println!("   • No intermediate allocations\n");

    println!("✅ Composable:");
    println!("   • Build queries incrementally");
    println!("   • Reuse query fragments");
    println!("   • Clean separation of query building vs execution\n");

    println!("✅ Zero Overhead:");
    println!("   • Compiles to same code as manual loops");
    println!("   • No runtime cost for abstraction");
    println!("   • Pay only for what you use\n");

    println!("✓ Lazy evaluation demo complete!\n");
}

examples/custom_queryable.rs (line 400)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Custom Queryable Implementation Demo                         ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // ============================================================================
    // DEMO 1: PaginatedCollection
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 1: PaginatedCollection (custom container)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut paginated = PaginatedCollection::new(3); // 3 items per page
    
    paginated.add(create_sample_product(1, "Laptop", 999.0, "Electronics", true));
    paginated.add(create_sample_product(2, "Mouse", 29.0, "Electronics", true));
    paginated.add(create_sample_product(3, "Keyboard", 129.0, "Electronics", true));
    paginated.add(create_sample_product(4, "Desk", 299.0, "Furniture", true));
    paginated.add(create_sample_product(5, "Chair", 199.0, "Furniture", false));

    println!("  Created paginated collection:");
    println!("    Total items: {}", paginated.total_items());
    println!("    Pages: {}", paginated.pages.len());

    // Now we can query it using the Queryable trait!
    // Collect to owned Vec for querying
    let items: Vec<Product> = paginated.query_iter().cloned().collect();
    let query = Query::new(&items)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query.all();
    
    println!("\n  Querying paginated collection:");
    println!("    Electronics found: {}", electronics.len());
    for product in electronics {
        println!("      • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // DEMO 2: CircularBuffer
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 2: CircularBuffer (fixed capacity)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut circular = CircularBuffer::new(3); // Capacity: 3
    
    circular.push(create_sample_product(1, "Product 1", 100.0, "A", true));
    circular.push(create_sample_product(2, "Product 2", 200.0, "B", true));
    circular.push(create_sample_product(3, "Product 3", 300.0, "C", true));
    circular.push(create_sample_product(4, "Product 4", 400.0, "D", true)); // Pushes out Product 1

    println!("  Circular buffer (capacity 3, added 4 items):");
    println!("    Current size: {}", circular.len());

    // Query the circular buffer
    let circ_items: Vec<Product> = circular.query_iter().cloned().collect();
    let circ_query = Query::new(&circ_items);
    let avg_price = circ_query.avg(Product::price_r()).unwrap_or(0.0);
    
    println!("\n  Querying circular buffer:");
    println!("    Average price: ${:.2}", avg_price);
    println!("    Items:");
    for (i, product) in circ_items.iter().enumerate() {
        println!("      {}. {}: ${:.2}", i + 1, product.name, product.price);
    }

    // ============================================================================
    // DEMO 3: FilteredStorage
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 3: FilteredStorage (auto-filtering container)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut filtered = FilteredStorage::new(|p: &Product| p.price < 200.0);
    
    println!("  FilteredStorage (only accepts items < $200):");
    println!("    Adding Laptop ($999): {}", filtered.add(create_sample_product(1, "Laptop", 999.0, "Electronics", true)));
    println!("    Adding Mouse ($29): {}", filtered.add(create_sample_product(2, "Mouse", 29.0, "Electronics", true)));
    println!("    Adding Keyboard ($129): {}", filtered.add(create_sample_product(3, "Keyboard", 129.0, "Electronics", true)));
    println!("    Total stored: {}", filtered.len());

    // Query the filtered storage
    let filt_items: Vec<Product> = filtered.query_iter().cloned().collect();
    let filt_query = Query::new(&filt_items)
        .where_(Product::in_stock_r(), |&v| v);
    let in_stock = filt_query.all();
    
    println!("\n  Querying filtered storage:");
    println!("    In stock items: {}", in_stock.len());

    // ============================================================================
    // DEMO 4: CategoryIndex
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 4: CategoryIndex (indexed by category)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut category_index = CategoryIndex::new();
    
    category_index.add("Electronics".to_string(), create_sample_product(1, "Monitor", 349.0, "Electronics", true));
    category_index.add("Electronics".to_string(), create_sample_product(2, "Webcam", 79.0, "Electronics", true));
    category_index.add("Furniture".to_string(), create_sample_product(3, "Desk", 299.0, "Furniture", true));
    category_index.add("Furniture".to_string(), create_sample_product(4, "Lamp", 39.0, "Furniture", true));

    println!("  CategoryIndex:");
    println!("    Categories: {:?}", category_index.categories());
    println!("    Total items: {}", category_index.total_items());

    // Query across all categories
    let idx_items: Vec<Product> = category_index.query_iter().cloned().collect();
    let idx_query = Query::new(&idx_items);
    let expensive = idx_query
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive_items = expensive.all();
    
    println!("\n  Querying category index:");
    println!("    Expensive items (>$100): {}", expensive_items.len());
    for product in expensive_items {
        println!("      • {}: ${:.2} ({})", product.name, product.price, product.category);
    }

    // ============================================================================
    // DEMO 5: LazyLoader
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 5: LazyLoader (simulated lazy loading)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let loader = LazyLoader::new(vec![
        create_sample_product(1, "Item 1", 50.0, "A", true),
        create_sample_product(2, "Item 2", 150.0, "B", true),
        create_sample_product(3, "Item 3", 250.0, "C", true),
    ]);

    println!("  LazyLoader:");
    println!("    Total available: {}", loader.total_count());
    println!("    Currently loaded: {}", loader.loaded_count());

    // Query loaded items
    let loader_items: Vec<Product> = loader.query_iter().cloned().collect();
    let loader_query = Query::new(&loader_items);
    let total_value = loader_query.sum(Product::price_r());
    
    println!("\n  Querying lazy loader:");
    println!("    Total value: ${:.2}", total_value);

    // ============================================================================
    // DEMO 6: Custom Container with LazyQuery
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 6: Using LazyQuery with custom containers");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut circular = CircularBuffer::new(5);
    for i in 1..=10 {
        circular.push(create_sample_product(
            i,
            &format!("Product {}", i),
            i as f64 * 50.0,
            if i % 2 == 0 { "Even" } else { "Odd" },
            true,
        ));
    }

    println!("  Circular buffer (capacity 5, added 10 items):");
    println!("    Current size: {}", circular.len());

    // Use LazyQuery for early termination!
    let circ_vec: Vec<Product> = circular.query_iter().cloned().collect();
    let first_expensive = LazyQuery::new(&circ_vec)
        .where_(Product::price_r(), |&p| p > 300.0)
        .first();

    if let Some(product) = first_expensive {
        println!("\n  First expensive item (lazy query):");
        println!("    {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // DEMO 7: Implementing Queryable for Wrapper Types
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 7: Queryable for wrapper types");
    println!("═══════════════════════════════════════════════════════════════\n");

    /// A simple wrapper around Vec with metadata
    struct VersionedCollection<T> {
        items: Vec<T>,
        version: u32,
        last_modified: String,
    }

    impl<T> Queryable<T> for VersionedCollection<T> {
        fn query_iter(&self) -> Box<dyn Iterator<Item = &T> + '_> {
            Box::new(self.items.iter())
        }
    }

    let versioned = VersionedCollection {
        items: vec![
            create_sample_product(1, "V1 Product", 99.0, "Test", true),
            create_sample_product(2, "V2 Product", 199.0, "Test", true),
        ],
        version: 2,
        last_modified: "2025-10-11".to_string(),
    };

    println!("  VersionedCollection:");
    println!("    Version: {}", versioned.version);
    println!("    Last modified: {}", versioned.last_modified);

    let versioned_items: Vec<Product> = versioned.query_iter().cloned().collect();
    let query = Query::new(&versioned_items);
    println!("    Items: {}", query.count());

    // ============================================================================
    // DEMO 8: Real-World Example - Cache with TTL
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 8: Cache container (real-world example)");
    println!("═══════════════════════════════════════════════════════════════\n");

    use std::time::{Duration, SystemTime};

    struct CachedItem<T> {
        item: T,
        inserted_at: SystemTime,
        ttl: Duration,
    }

    struct Cache<T> {
        items: Vec<CachedItem<T>>,
    }

    impl<T> Cache<T> {
        fn new() -> Self {
            Self { items: Vec::new() }
        }

        fn insert(&mut self, item: T, ttl: Duration) {
            self.items.push(CachedItem {
                item,
                inserted_at: SystemTime::now(),
                ttl,
            });
        }

        fn valid_items(&self) -> Vec<&T> {
            let now = SystemTime::now();
            self.items
                .iter()
                .filter(|cached| {
                    now.duration_since(cached.inserted_at)
                        .map_or(false, |elapsed| elapsed < cached.ttl)
                })
                .map(|cached| &cached.item)
                .collect()
        }
    }

    // Implement Queryable to query only valid (non-expired) items
    impl<T> Queryable<T> for Cache<T> {
        fn query_iter(&self) -> Box<dyn Iterator<Item = &T> + '_> {
            let now = SystemTime::now();
            Box::new(
                self.items
                    .iter()
                    .filter(move |cached| {
                        now.duration_since(cached.inserted_at)
                            .map_or(false, |elapsed| elapsed < cached.ttl)
                    })
                    .map(|cached| &cached.item),
            )
        }
    }

    let mut cache = Cache::new();
    cache.insert(create_sample_product(1, "Cached Item 1", 100.0, "A", true), Duration::from_secs(60));
    cache.insert(create_sample_product(2, "Cached Item 2", 200.0, "B", true), Duration::from_secs(60));

    let valid = cache.valid_items();
    println!("  Cache:");
    println!("    Total items: {}", cache.items.len());
    println!("    Valid items: {}", valid.len());

    // Query the cache
    let cache_items: Vec<Product> = cache.query_iter().cloned().collect();
    let cache_query = Query::new(&cache_items);
    println!("    Queryable items: {}", cache_query.count());

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: Implementing Queryable                              ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ How to make any container queryable:\n");
    println!("  1. Implement the Queryable<T> trait:");
    println!("     ```rust");
    println!("     impl<T> Queryable<T> for MyContainer<T> {{");
    println!("         fn query_iter(&self) -> Box<dyn Iterator<Item = &T> + '_> {{");
    println!("             Box::new(self.items.iter())");
    println!("         }}");
    println!("     }}");
    println!("     ```\n");

    println!("  2. Convert to Vec or slice for querying:");
    println!("     ```rust");
    println!("     let items: Vec<&Product> = container.query_iter().collect();");
    println!("     let query = Query::new(&items);");
    println!("     ```\n");

    println!("  3. Now use all query operations:");
    println!("     ```rust");
    println!("     let results = query.where_(...).all();");
    println!("     let count = query.count();");
    println!("     let total = query.sum(field);");
    println!("     ```\n");

    println!("📝 Custom containers demonstrated:");
    println!("   • PaginatedCollection - Items stored in pages");
    println!("   • CircularBuffer - Fixed-capacity FIFO buffer");
    println!("   • FilteredStorage - Auto-filtering container");
    println!("   • CategoryIndex - Indexed by category");
    println!("   • LazyLoader - Simulated lazy loading");
    println!("   • VersionedCollection - Wrapper with metadata");
    println!("   • Cache - TTL-based cache\n");

    println!("💡 Use cases:");
    println!("   • Database result wrappers");
    println!("   • Custom data structures");
    println!("   • Specialized collections");
    println!("   • Caches and buffers");
    println!("   • Event streams");
    println!("   • Any container that holds items!\n");

    println!("✓ Custom Queryable demo complete!\n");
}

examples/macro_helpers.rs (line 326)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Macro Helpers Demo - Reducing Boilerplate                    ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    let products = create_products();

    // ============================================================================
    // EXAMPLE 1: Simple Collection
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 1: collect_lazy! - Simple collection");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let results: Vec<_> = LazyQuery::new(&products).collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let results = collect_lazy!(&products);");
    println!("```\n");

    let results = collect_lazy!(&products);
    println!("Result: {} products collected\n", results.len());

    // ============================================================================
    // EXAMPLE 2: Filter and Collect
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 2: filter_collect! - Filter and collect");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let electronics: Vec<_> = LazyQuery::new(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Electronics\")");
    println!("    .collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let electronics = filter_collect!(");
    println!("    &products,");
    println!("    Product::category_r(),");
    println!("    |cat| cat == \"Electronics\"");
    println!(");");
    println!("```\n");

    let electronics = filter_collect!(
        &products,
        Product::category_r(),
        |cat| cat == "Electronics"
    );
    println!("Result: {} electronics\n", electronics.len());

    // ============================================================================
    // EXAMPLE 3: Count with Filter
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 3: count_where! - Count with filter");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let count = LazyQuery::new(&products)");
    println!("    .where_(Product::stock_r(), |&s| s > 0)");
    println!("    .count();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let count = count_where!(&products, Product::stock_r(), |&s| s > 0);");
    println!("```\n");

    let count = count_where!(&products, Product::stock_r(), |&s| s > 0);
    println!("Result: {} products in stock\n", count);

    // ============================================================================
    // EXAMPLE 4: Find First
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 4: find_first! - Find first matching item");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let found = LazyQuery::new(&products)");
    println!("    .where_(Product::price_r(), |&p| p > 500.0)");
    println!("    .first();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let found = find_first!(&products, Product::price_r(), |&p| p > 500.0);");
    println!("```\n");

    let found = find_first!(&products, Product::price_r(), |&p| p > 500.0);
    if let Some(p) = found {
        println!("Result: Found {} at ${:.2}\n", p.name, p.price);
    }

    // ============================================================================
    // EXAMPLE 5: Existence Check
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 5: exists_where! - Check if any item matches");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let has_furniture = LazyQuery::new(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Furniture\")");
    println!("    .any();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let has_furniture = exists_where!(");
    println!("    &products,");
    println!("    Product::category_r(),");
    println!("    |cat| cat == \"Furniture\"");
    println!(");");
    println!("```\n");

    let has_furniture = exists_where!(
        &products,
        Product::category_r(),
        |cat| cat == "Furniture"
    );
    println!("Result: Has furniture = {}\n", has_furniture);

    // ============================================================================
    // EXAMPLE 6: Pagination
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 6: paginate! - Quick pagination");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let page_2: Vec<_> = LazyQuery::new(&products)");
    println!("    .skip_lazy(1 * 2)  // page * size");
    println!("    .take_lazy(2)");
    println!("    .collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let page_2 = paginate!(&products, page: 1, size: 2);");
    println!("```\n");

    let page_2 = paginate!(&products, page: 1, size: 2);
    println!("Result: Page 2 has {} items\n", page_2.len());

    // ============================================================================
    // EXAMPLE 7: Sum with Filter
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 7: sum_where! - Sum with filter");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let total: f64 = LazyQuery::new(&products)");
    println!("    .where_(Product::active_r(), |&a| a)");
    println!("    .sum_by(Product::price_r());");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let total = sum_where!(&products, Product::price_r(), Product::active_r(), |&a| a);");
    println!("```\n");

    let total = sum_where!(&products, Product::price_r(), Product::active_r(), |&a| a);
    println!("Result: Total active products value = ${:.2}\n", total);

    // ============================================================================
    // EXAMPLE 8: Average with Filter
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 8: avg_where! - Average with filter");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let avg = LazyQuery::new(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Electronics\")");
    println!("    .avg_by(Product::price_r())");
    println!("    .unwrap_or(0.0);");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let avg = avg_where!(");
    println!("    &products,");
    println!("    Product::price_r(),");
    println!("    Product::category_r(),");
    println!("    |cat| cat == \"Electronics\"");
    println!(").unwrap_or(0.0);");
    println!("```\n");

    let avg = avg_where!(
        &products,
        Product::price_r(),
        Product::category_r(),
        |cat| cat == "Electronics"
    ).unwrap_or(0.0);
    println!("Result: Average electronics price = ${:.2}\n", avg);

    // ============================================================================
    // EXAMPLE 9: Select All
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 9: select_all! - Select field from all items");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let names: Vec<String> = LazyQuery::new(&products)");
    println!("    .select_lazy(Product::name_r())");
    println!("    .collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let names = select_all!(&products, Product::name_r());");
    println!("```\n");

    let names: Vec<String> = select_all!(&products, Product::name_r());
    println!("Result: {} product names\n", names.len());

    // ============================================================================
    // EXAMPLE 10: Select with Filter
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 10: select_where! - Select field with filter");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let furniture_names: Vec<String> = LazyQuery::new(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Furniture\")");
    println!("    .select_lazy(Product::name_r())");
    println!("    .collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let furniture_names = select_where!(");
    println!("    &products,");
    println!("    Product::name_r(),");
    println!("    Product::category_r(),");
    println!("    |cat| cat == \"Furniture\"");
    println!(");");
    println!("```\n");

    let furniture_names: Vec<String> = select_where!(
        &products,
        Product::name_r(),
        Product::category_r(),
        |cat| cat == "Furniture"
    );
    println!("Result: {} furniture items\n", furniture_names.len());

    // ============================================================================
    // COMPARISON: Complex Query
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Before & After");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Filter electronics, under $500, in stock, get first 5\n");

    println!("❌ WITHOUT MACROS (13 lines):");
    println!("```rust");
    println!("let results: Vec<_> = LazyQuery::new(&products)");
    println!("    .where_(");
    println!("        Product::category_r(),");
    println!("        |cat| cat == \"Electronics\"");
    println!("    )");
    println!("    .where_(Product::price_r(), |&p| p < 500.0)");
    println!("    .where_(Product::stock_r(), |&s| s > 0)");
    println!("    .take_lazy(5)");
    println!("    .collect();");
    println!("```\n");

    // Actual verbose version
    let verbose_results: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .where_(Product::stock_r(), |&s| s > 0)
        .take_lazy(5)
        .collect();

    println!("✅ WITH MACROS (Shorter, but still need multiple filters):");
    println!("```rust");
    println!("let results = lazy_query!(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Electronics\")");
    println!("    .where_(Product::price_r(), |&p| p < 500.0)");
    println!("    .where_(Product::stock_r(), |&s| s > 0)");
    println!("    .take_lazy(5)");
    println!("    .collect();");
    println!("```\n");

    let macro_results = lazy_query!(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .where_(Product::stock_r(), |&s| s > 0)
        .take_lazy(5)
        .collect();

    println!("Both approaches found {} items ✅\n", verbose_results.len());
    assert_eq!(verbose_results.len(), macro_results.len());

    // ============================================================================
    // CODE REDUCTION METRICS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Code Reduction Metrics");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Pattern Comparisons:\n");

    println!("  1. Simple collect:");
    println!("     Before: LazyQuery::new(&data).collect()");
    println!("     After:  collect_lazy!(&data)");
    println!("     Saved:  ~20 characters\n");

    println!("  2. Filter + collect:");
    println!("     Before: LazyQuery::new(&data).where_(...).collect()");
    println!("     After:  filter_collect!(&data, field, pred)");
    println!("     Saved:  ~35 characters\n");

    println!("  3. Count with filter:");
    println!("     Before: LazyQuery::new(&data).where_(...).count()");
    println!("     After:  count_where!(&data, field, pred)");
    println!("     Saved:  ~30 characters\n");

    println!("  4. Pagination:");
    println!("     Before: LazyQuery::new(&data).skip_lazy(p*s).take_lazy(s).collect()");
    println!("     After:  paginate!(&data, page: p, size: s)");
    println!("     Saved:  ~45 characters\n");

    println!("  5. Sum with filter:");
    println!("     Before: LazyQuery::new(&data).where_(...).sum_by(...)");
    println!("     After:  sum_where!(&data, sum_field, filter_field, pred)");
    println!("     Saved:  ~25 characters\n");

    // ============================================================================
    // ALL MACRO DEMONSTRATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("All Available Macros - Quick Reference");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("1. lazy_query!(&data)");
    let _q1 = lazy_query!(&products);
    println!("   → LazyQuery::new(&data)\n");

    println!("2. query!(&data)");
    let _q2 = query!(&products);
    println!("   → Query::new(&data)\n");

    println!("3. collect_lazy!(&data)");
    let _r3 = collect_lazy!(&products);
    println!("   → LazyQuery::new(&data).collect()\n");

    println!("4. filter_collect!(&data, field, pred)");
    let _r4 = filter_collect!(&products, Product::active_r(), |&a| a);
    println!("   → LazyQuery::new(&data).where_(field, pred).collect()\n");

    println!("5. count_where!(&data, field, pred)");
    let _r5 = count_where!(&products, Product::active_r(), |&a| a);
    println!("   → LazyQuery::new(&data).where_(field, pred).count()\n");

    println!("6. find_first!(&data, field, pred)");
    let _r6 = find_first!(&products, Product::id_r(), |&id| id == 1);
    println!("   → LazyQuery::new(&data).where_(field, pred).first()\n");

    println!("7. exists_where!(&data, field, pred)");
    let _r7 = exists_where!(&products, Product::active_r(), |&a| a);
    println!("   → LazyQuery::new(&data).where_(field, pred).any()\n");

    println!("8. paginate!(&data, page: p, size: s)");
    let _r8 = paginate!(&products, page: 0, size: 3);
    println!("   → LazyQuery::new(&data).skip_lazy(p*s).take_lazy(s).collect()\n");

    println!("9. sum_where!(&data, sum_field, filter_field, pred)");
    let _r9 = sum_where!(&products, Product::price_r(), Product::active_r(), |&a| a);
    println!("   → LazyQuery::new(&data).where_(filter_field, pred).sum_by(sum_field)\n");

    println!("10. avg_where!(&data, avg_field, filter_field, pred)");
    let _r10 = avg_where!(&products, Product::price_r(), Product::active_r(), |&a| a);
    println!("    → LazyQuery::new(&data).where_(filter_field, pred).avg_by(avg_field)\n");

    println!("11. select_all!(&data, field)");
    let _r11: Vec<String> = select_all!(&products, Product::name_r());
    println!("    → LazyQuery::new(&data).select_lazy(field).collect()\n");

    println!("12. select_where!(&data, select_field, filter_field, pred)");
    let _r12: Vec<String> = select_where!(&products, Product::name_r(), Product::active_r(), |&a| a);
    println!("    → LazyQuery::new(&data).where_(filter, pred).select_lazy(field).collect()\n");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("╔════════════════════════════════════════════════════════════════╗");
    println!("║  Summary                                                       ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ 12 helper macros provided:");
    println!("   • lazy_query! - Create LazyQuery");
    println!("   • query! - Create Query");
    println!("   • collect_lazy! - Quick collect");
    println!("   • filter_collect! - Filter and collect");
    println!("   • count_where! - Count with filter");
    println!("   • find_first! - Find first match");
    println!("   • exists_where! - Existence check");
    println!("   • paginate! - Easy pagination");
    println!("   • sum_where! - Sum with filter");
    println!("   • avg_where! - Average with filter");
    println!("   • select_all! - Select all");
    println!("   • select_where! - Select with filter\n");

    println!("📊 Benefits:");
    println!("   • Less typing (20-45 characters saved per operation)");
    println!("   • More readable code");
    println!("   • Common patterns encapsulated");
    println!("   • Same performance (zero-cost abstraction)");
    println!("   • Type-safe (compile-time checked)\n");

    println!("💡 When to use:");
    println!("   • Use macros for simple, common patterns");
    println!("   • Use full API for complex queries");
    println!("   • Mix and match as needed\n");

    println!("✓ Macro helpers demo complete!\n");
}

Additional examples can be found in:

• examples/arc_rwlock_hashmap.rs

pub fn map_items<F, O>(self, f: F) -> impl Iterator<Item = O> + 'a

where F: Fn(&'a T) -> O + 'a, I: 'a,

Maps each item through a transformation (lazy).

Example

let prices = LazyQuery::new(&products)
    .map_items(|p| p.price)
    .collect::<Vec<_>>();

Examples found in repository

examples/derive_and_ext.rs (line 128)

fn main() {
    println!("Derive Macros and Extension Traits Example");
    println!("===========================================\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. Using Extension Trait - Direct .query() on Vec");
    println!("   Query: products.query().where_(price > 100).all()");
    
    let query = products
        .query()
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in &expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. Using Extension Trait - Direct .lazy_query() on Vec");
    println!("   Query: products.lazy_query().where_(stock < 10).collect()");
    
    let low_stock: Vec<_> = products
        .lazy_query()
        .where_(Product::stock_r(), |&s| s < 10)
        .collect();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in &low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. Using Extension Trait - Chained Operations");
    println!("   Query: products.lazy_query().where_(category == Electronics).take(2).select(name).collect()");
    
    let names: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(2)
        .select_lazy(Product::name_r())
        .collect();
    
    println!("   First 2 electronics:");
    for name in &names {
        println!("   - {}", name);
    }
    println!();

    println!("4. Using QueryBuilder Derive - Static Methods");
    println!("   Query: Product::query(&products).where_(price > 50).count()");
    
    let query4 = Product::query(&products)
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query4.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("5. Using QueryBuilder Derive - Lazy Static Methods");
    println!("   Query: Product::lazy_query(&products).first()");
    
    if let Some(first) = Product::lazy_query(&products).first() {
        println!("   First product: {} (${:.2})", first.name, first.price);
    }
    println!();

    println!("6. Complex Chain with Extension Trait");
    println!("   Query: products.lazy_query()");
    println!("          .where_(category == Electronics)");
    println!("          .where_(price < 500)");
    println!("          .map(|p| format!(\"{{}} - ${{:.2}}\", p.name, p.price))");
    println!("          .collect()");
    
    let formatted: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .map_items(|p| format!("{} - ${:.2}", p.name, p.price))
        .collect();
    
    println!("   Affordable electronics:");
    for item in &formatted {
        println!("   - {}", item);
    }
    println!();

    println!("7. Aggregation with Extension Trait");
    println!("   Query: products.lazy_query().sum_by(Product::stock())");
    
    let total_stock = products
        .lazy_query()
        .sum_by(Product::stock_r());
    
    println!("   Total stock across all products: {}", total_stock);
    println!();

    println!("8. Find with Extension Trait");
    println!("   Query: products.lazy_query().find(|p| p.name.contains(\"Chair\"))");
    
    if let Some(chair) = products.lazy_query().find(|p| p.name.contains("Chair")) {
        println!("   Found: {} in {}", chair.name, chair.category);
    }
    println!();

    println!("9. Early Termination with Extension Trait");
    println!("   Query: products.lazy_query().where_(price > 1000).any()");
    
    let has_luxury = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p > 1000.0)
        .any();
    
    println!("   Has products over $1000: {}", has_luxury);
    println!();

    println!("10. Slice Extension Trait");
    println!("    Query: (&products[..]).lazy_query().count()");
    
    let slice_count = (&products[..])
        .lazy_query()
        .count();
    
    println!("    Count from slice: {}", slice_count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ Extension trait QueryExt adds .query() and .lazy_query() to containers");
    println!("✓ Derive macro QueryBuilder adds static methods Product::query() and Product::lazy_query()");
    println!("✓ Both approaches provide the same query functionality");
    println!("✓ Extension trait is more ergonomic: products.query() vs Query::new(&products)");
    println!("✓ All iterator optimizations (fusion, early termination) still apply");
}

examples/arc_rwlock_hashmap.rs (line 327)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Arc<RwLock<T>> HashMap Lazy Query Demo                         ║");
    println!("║  Thread-safe shared data with lazy evaluation                   ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    let product_map = create_sample_data();
    println!("Created product catalog:");
    println!("  Total products: {}", product_map.len());
    println!("  Keys: {:?}\n", product_map.keys().take(3).collect::<Vec<_>>());

    // Extract products for querying
    let products = extract_products(&product_map);
    println!("Extracted {} products from Arc<RwLock<Product>>\n", products.len());

    // ============================================================================
    // LAZY OPERATION 1: where_ - Lazy Filtering
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 1: where_ (filtering)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building filtered query (nothing executes yet)...");
    let electronics_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::active_r(), |&active| active)
        .where_(Product::stock_r(), |&stock| stock > 20);

    println!("  ✅ Query built (deferred execution)\n");

    println!("Collecting results (executes now)...");
    let electronics: Vec<_> = electronics_query.collect();
    println!("  Found {} electronics in stock", electronics.len());
    for p in &electronics {
        println!("    • {}: {} in stock", p.name, p.stock);
    }

    // ============================================================================
    // LAZY OPERATION 2: select_lazy - Lazy Projection
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 2: select_lazy (projection)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting product names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .select_lazy(Product::name_r())
        .collect();

    println!("  Furniture names ({}):", names.len());
    for name in &names {
        println!("    • {}", name);
    }

    // ============================================================================
    // LAZY OPERATION 3: take_lazy - Early Termination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 3: take_lazy (early termination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting first 3 electronics...");
    let first_3: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
        .collect();

    println!("  First 3 electronics:");
    for (i, p) in first_3.iter().enumerate() {
        println!("    {}. {} - ${:.2}", i + 1, p.name, p.price);
    }
    println!("  ✅ Stopped after finding 3 items!");

    // ============================================================================
    // LAZY OPERATION 4: skip_lazy - Pagination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 4: skip_lazy (pagination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting page 2 (skip 3, take 3)...");
    let page_2: Vec<_> = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .skip_lazy(3)
        .take_lazy(3)
        .collect();

    println!("  Page 2 items:");
    for (i, p) in page_2.iter().enumerate() {
        println!("    {}. {}", i + 4, p.name);
    }

    // ============================================================================
    // LAZY OPERATION 5: first - Short-Circuit Search
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 5: first (short-circuit)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Finding first expensive item (>$1000)...");
    let expensive = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0)
        .first();

    match expensive {
        Some(p) => println!("  Found: {} - ${:.2}", p.name, p.price),
        None => println!("  Not found"),
    }
    println!("  ✅ Stopped at first match!");

    // ============================================================================
    // LAZY OPERATION 6: any - Existence Check
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 6: any (existence check)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Checking if any furniture exists...");
    let has_furniture = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .any();

    println!("  Has furniture: {}", has_furniture);
    println!("  ✅ Stopped immediately after finding first match!");

    // ============================================================================
    // LAZY OPERATION 7: count - Count Matching Items
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 7: count");
    println!("═══════════════════════════════════════════════════════════════\n");

    let electronics_count = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .count();

    println!("  Electronics count: {}", electronics_count);

    // ============================================================================
    // LAZY OPERATION 8: sum_by - Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 8: sum_by (aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_value: f64 = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .sum_by(Product::price_r());

    println!("  Total electronics value: ${:.2}", total_value);

    // ============================================================================
    // LAZY OPERATION 9: avg_by - Average
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 9: avg_by");
    println!("═══════════════════════════════════════════════════════════════\n");

    let avg_price = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .avg_by(Product::price_r())
        .unwrap_or(0.0);

    println!("  Average furniture price: ${:.2}", avg_price);

    // ============================================================================
    // LAZY OPERATION 10: min_by_float / max_by_float
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 10: min_by_float / max_by_float");
    println!("═══════════════════════════════════════════════════════════════\n");

    let min_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .min_by_float(Product::price_r())
        .unwrap_or(0.0);

    let max_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .max_by_float(Product::price_r())
        .unwrap_or(0.0);

    println!("  Price range for active products:");
    println!("    Min: ${:.2}", min_price);
    println!("    Max: ${:.2}", max_price);

    // ============================================================================
    // LAZY OPERATION 11: find - Find with Predicate
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 11: find (with predicate)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let high_rated = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .find(|item| item.rating > 4.7);

    if let Some(product) = high_rated {
        println!("  First highly-rated electronic:");
        println!("    {}: Rating {:.1}", product.name, product.rating);
    }

    // ============================================================================
    // LAZY OPERATION 12: for_each - Iteration
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 12: for_each (iteration)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  Low stock alerts:");
    LazyQuery::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .for_each(|product| {
            println!("    ⚠️  {}: Only {} in stock", product.name, product.stock);
        });

    // ============================================================================
    // LAZY OPERATION 13: fold - Custom Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 14: fold (custom aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_inventory_value = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .fold(0.0, |acc, product| {
            acc + (product.price * product.stock as f64)
        });

    println!("  Total inventory value: ${:.2}", total_inventory_value);

    // ============================================================================
    // LAZY OPERATION 14: all_match - Validation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 15: all_match (validation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let all_priced = LazyQuery::new(&products)
        .all_match(|item| item.price > 0.0);

    println!("  All products have valid prices: {}", all_priced);

    // ============================================================================
    // LAZY OPERATION 15: into_iter - For Loop
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 16: into_iter (for loop)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  High-value products (>$300):");
    for product in LazyQuery::new(&products)
        .where_(Product::price_r(), |&p| p > 300.0)
        .take_lazy(5)
    {
        println!("    • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // LAZY OPERATION 16: map_items - Transform
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 17: map_items (transformation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let price_tags: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .map_items(|p| format!("{}: ${:.2}", p.name, p.price))
        .take(5)
        .collect();

    println!("  Electronics price tags:");
    for tag in &price_tags {
        println!("    • {}", tag);
    }

    // ============================================================================
    // COMPLEX EXAMPLE: Multi-Stage Lazy Pipeline
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Multi-stage lazy pipeline");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building complex query:");
    println!("  1. Filter by category (Electronics)");
    println!("  2. Filter by price range ($50-$500)");
    println!("  3. Filter by rating (>4.5)");
    println!("  4. Select names");
    println!("  5. Take first 3");
    println!();

    let results: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p >= 50.0 && p <= 500.0)
        .where_(Product::rating_r(), |&r| r > 4.5)
        .select_lazy(Product::name_r())
        .take(3)
        .collect();

    println!("  Results:");
    for (i, name) in results.iter().enumerate() {
        println!("    {}. {}", i + 1, name);
    }
    println!("  ✅ All operations fused and executed lazily!");

    // ============================================================================
    // THREAD-SAFE UPDATES WITH RWLOCK
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Bonus: Thread-safe updates with RwLock");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Update a product through the Arc<RwLock>
    if let Some(product_arc) = product_map.get("PROD-002") {
        println!("Updating PROD-002 stock...");
        
        // Write lock for mutation
        if let Ok(mut product) = product_arc.write() {
            let old_stock = product.stock;
            product.stock = 25;
            println!("  Stock updated: {} → {}", old_stock, product.stock);
        }
    }

    // Query again to see the update
    let updated_products = extract_products(&product_map);
    let mouse = LazyQuery::new(&updated_products)
        .find(|p| p.id == 2);

    if let Some(product) = mouse {
        println!("  Verified update: {} now has {} in stock", product.name, product.stock);
    }

    // ============================================================================
    // PRACTICAL EXAMPLE: Price Analysis by Category
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Practical Example: Price analysis by category");
    println!("═══════════════════════════════════════════════════════════════\n");

    let categories = vec!["Electronics", "Furniture"];

    for category in categories {
        println!("  {} Statistics:", category);
        
        // Filter products by category first
        let cat_products: Vec<Product> = products.iter()
            .filter(|p| p.category == category)
            .cloned()
            .collect();

        let count = LazyQuery::new(&cat_products).count();
        let total = LazyQuery::new(&cat_products).sum_by(Product::price_r());
        let avg = LazyQuery::new(&cat_products).avg_by(Product::price_r()).unwrap_or(0.0);
        let min = LazyQuery::new(&cat_products).min_by_float(Product::price_r()).unwrap_or(0.0);
        let max = LazyQuery::new(&cat_products).max_by_float(Product::price_r()).unwrap_or(0.0);

        println!("    Count: {}", count);
        println!("    Total: ${:.2}", total);
        println!("    Average: ${:.2}", avg);
        println!("    Range: ${:.2} - ${:.2}\n", min, max);
    }

    // ============================================================================
    // COMBINING WITH HASHMAP OPERATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("HashMap Integration: Query by key patterns");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Filter HashMap by key pattern
    let electronics_keys: Vec<String> = product_map
        .iter()
        .filter(|(_key, value)| {
            // Read the value to check category
            if let Ok(guard) = value.read() {
                guard.category == "Electronics"
            } else {
                false
            }
        })
        .map(|(key, _value)| key.clone())
        .collect();

    println!("  Electronics product IDs:");
    for key in electronics_keys.iter().take(5) {
        println!("    • {}", key);
    }

    // ============================================================================
    // PERFORMANCE DEMONSTRATION
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Performance: Lazy vs Eager comparison");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first product with rating > 4.7 from {} products\n", products.len());

    println!("  Eager approach (hypothetical):");
    println!("    - Filter all {} products", products.len());
    println!("    - Collect filtered results");
    println!("    - Take first item");
    println!("    - Wasted work: Check all items\n");

    println!("  Lazy approach (actual):");
    let _first_rated = LazyQuery::new(&products)
        .where_(Product::rating_r(), |&r| r > 4.7)
        .first();
    println!("    - Starts checking products");
    println!("    - Stops at first match");
    println!("    - ✅ Early termination - checks ~3-5 items only!");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: All Lazy Operations Demonstrated                      ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Lazy Query Operations:");
    println!("   1. ✅ where_ - Lazy filtering");
    println!("   2. ✅ select_lazy - Lazy projection");
    println!("   3. ✅ take_lazy - Early termination");
    println!("   4. ✅ skip_lazy - Pagination");
    println!("   5. ✅ first - Short-circuit search");
    println!("   6. ✅ any - Existence check (short-circuit)");
    println!("   7. ✅ count - Count items");
    println!("   8. ✅ sum_by - Sum aggregation");
    println!("   9. ✅ avg_by - Average aggregation");
    println!("   10. ✅ min_by_float - Minimum value");
    println!("   11. ✅ max_by_float - Maximum value");
    println!("   12. ✅ find - Find with predicate (short-circuit)");
    println!("   13. ✅ for_each - Iteration");
    println!("   14. ✅ fold - Custom aggregation");
    println!("   15. ✅ all_match - Validation (short-circuit)");
    println!("   16. ✅ into_iter - For loop support");
    println!("   17. ✅ map_items - Transformation\n");

    println!("✅ Arc<RwLock<T>> Benefits:");
    println!("   • Thread-safe shared access");
    println!("   • Interior mutability");
    println!("   • Multiple readers, single writer");
    println!("   • Reference counting (Arc)");
    println!("   • Can be queried after extracting data\n");

    println!("✅ HashMap<K, Arc<RwLock<V>>> Benefits:");
    println!("   • Fast key-based lookup");
    println!("   • Thread-safe value access");
    println!("   • Can query all values");
    println!("   • Can filter by key patterns");
    println!("   • Perfect for shared state/caches\n");

    println!("🎯 Use Cases:");
    println!("   • Shared product catalogs");
    println!("   • User session stores");
    println!("   • Configuration caches");
    println!("   • Real-time inventory systems");
    println!("   • Multi-threaded data processing");
    println!("   • Web server state management\n");

    println!("✓ Arc<RwLock<T>> HashMap with all lazy operations demo complete!\n");
}

pub fn select_lazy<F>( self, path: KeyPaths<T, F>, ) -> impl Iterator<Item = F> + 'a

where F: Clone + 'static, I: 'a,

Selects/projects a field value (lazy).

Returns iterator over cloned field values.

Example

let names: Vec<String> = LazyQuery::new(&products)
    .select_lazy(Product::name_r())
    .collect();

Examples found in repository

examples/derive_and_ext.rs (line 90)

fn main() {
    println!("Derive Macros and Extension Traits Example");
    println!("===========================================\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. Using Extension Trait - Direct .query() on Vec");
    println!("   Query: products.query().where_(price > 100).all()");
    
    let query = products
        .query()
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in &expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. Using Extension Trait - Direct .lazy_query() on Vec");
    println!("   Query: products.lazy_query().where_(stock < 10).collect()");
    
    let low_stock: Vec<_> = products
        .lazy_query()
        .where_(Product::stock_r(), |&s| s < 10)
        .collect();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in &low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. Using Extension Trait - Chained Operations");
    println!("   Query: products.lazy_query().where_(category == Electronics).take(2).select(name).collect()");
    
    let names: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(2)
        .select_lazy(Product::name_r())
        .collect();
    
    println!("   First 2 electronics:");
    for name in &names {
        println!("   - {}", name);
    }
    println!();

    println!("4. Using QueryBuilder Derive - Static Methods");
    println!("   Query: Product::query(&products).where_(price > 50).count()");
    
    let query4 = Product::query(&products)
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query4.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("5. Using QueryBuilder Derive - Lazy Static Methods");
    println!("   Query: Product::lazy_query(&products).first()");
    
    if let Some(first) = Product::lazy_query(&products).first() {
        println!("   First product: {} (${:.2})", first.name, first.price);
    }
    println!();

    println!("6. Complex Chain with Extension Trait");
    println!("   Query: products.lazy_query()");
    println!("          .where_(category == Electronics)");
    println!("          .where_(price < 500)");
    println!("          .map(|p| format!(\"{{}} - ${{:.2}}\", p.name, p.price))");
    println!("          .collect()");
    
    let formatted: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .map_items(|p| format!("{} - ${:.2}", p.name, p.price))
        .collect();
    
    println!("   Affordable electronics:");
    for item in &formatted {
        println!("   - {}", item);
    }
    println!();

    println!("7. Aggregation with Extension Trait");
    println!("   Query: products.lazy_query().sum_by(Product::stock())");
    
    let total_stock = products
        .lazy_query()
        .sum_by(Product::stock_r());
    
    println!("   Total stock across all products: {}", total_stock);
    println!();

    println!("8. Find with Extension Trait");
    println!("   Query: products.lazy_query().find(|p| p.name.contains(\"Chair\"))");
    
    if let Some(chair) = products.lazy_query().find(|p| p.name.contains("Chair")) {
        println!("   Found: {} in {}", chair.name, chair.category);
    }
    println!();

    println!("9. Early Termination with Extension Trait");
    println!("   Query: products.lazy_query().where_(price > 1000).any()");
    
    let has_luxury = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p > 1000.0)
        .any();
    
    println!("   Has products over $1000: {}", has_luxury);
    println!();

    println!("10. Slice Extension Trait");
    println!("    Query: (&products[..]).lazy_query().count()");
    
    let slice_count = (&products[..])
        .lazy_query()
        .count();
    
    println!("    Count from slice: {}", slice_count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ Extension trait QueryExt adds .query() and .lazy_query() to containers");
    println!("✓ Derive macro QueryBuilder adds static methods Product::query() and Product::lazy_query()");
    println!("✓ Both approaches provide the same query functionality");
    println!("✓ Extension trait is more ergonomic: products.query() vs Query::new(&products)");
    println!("✓ All iterator optimizations (fusion, early termination) still apply");
}

examples/lazy_evaluation.rs (line 141)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Lazy Query Evaluation Demo                                   ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    let products = create_products();
    println!("Created {} products\n", products.len());

    // ============================================================================
    // DEMO 1: Lazy Execution - Nothing Happens Until .collect()
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 1: Lazy execution - deferred until needed");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Building query (should execute nothing)...");
    let lazy_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            cat == "Electronics"
        });

    let evals_after_build = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Filter evaluations after building query: {}", evals_after_build);
    
    if evals_after_build == 0 {
        println!("  ✅ Confirmed: Query is lazy! Nothing executed yet.\n");
    }

    println!("Collecting results (now it executes)...");
    let results: Vec<_> = lazy_query.collect();

    let evals_after_collect = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Filter evaluations after collecting: {}", evals_after_collect);
    println!("  Results found: {}", results.len());
    println!("  ✅ Query executed exactly once, when needed!\n");

    // ============================================================================
    // DEMO 2: Early Termination - Stops as Soon as Enough Items Found
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 2: Early termination with .take()");
    println!("═══════════════════════════════════════════════════════════════\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);

    println!("Finding first 5 expensive items from 1000 products...");
    let first_5: Vec<_> = LazyQuery::new(&products)
        .where_(Product::price_r(), |p| expensive_check(p))
        .take_lazy(5)
        .collect();

    let ops = EXPENSIVE_OPERATIONS.load(Ordering::SeqCst);
    println!("  Found: {} items", first_5.len());
    println!("  Expensive operations performed: {}", ops);
    println!("  Items NOT checked: {} (stopped early!)", 1000 - ops);
    
    if ops < 1000 {
        println!("  ✅ Early termination worked! Didn't check all 1000 items.\n");
    }

    // ============================================================================
    // DEMO 3: Iterator Fusion - Rust Optimizes Chained Operations
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 3: Iterator fusion - chained operations optimized");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Chaining multiple operations...");
    let chained_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price > 200.0)
        .where_(Product::stock_r(), |&stock| stock > 10)
        .take_lazy(10);

    println!("  Built query with 3 filters + take(10)");
    println!("  ✅ No execution yet - all operations fused into one iterator\n");

    let results: Vec<_> = chained_query.collect();
    println!("  Executed: Found {} items", results.len());
    println!("  ✅ All filters applied in single pass!\n");

    // ============================================================================
    // DEMO 4: Lazy Projection - Only Extract What You Need
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 4: Lazy projection");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .select_lazy(Product::name_r())
        .take(5)  // Only process until we have 5
        .collect();

    println!("  Selected {} names", names.len());
    println!("  ✅ Only evaluated until 5 names found!\n");

    // ============================================================================
    // DEMO 5: Lazy Aggregation - Short-Circuit When Possible
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 5: Short-circuit with .any()");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Checking if ANY electronics exist (1000 items to search)...");
    let exists = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            cat == "Electronics"
        })
        .any();

    let checks = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Result: {}", exists);
    println!("  Items checked: {} out of 1000", checks);
    println!("  Items skipped: {} (short-circuited!)", 1000 - checks);
    
    if checks < 1000 {
        println!("  ✅ Short-circuit worked! Stopped as soon as first match found.\n");
    }

    // ============================================================================
    // DEMO 6: Lazy Find - Stops at First Match
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 6: .find() stops at first match");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Finding first product with price > 500...");
    let found = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            price > 500.0
        })
        .first();

    let checks = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    if let Some(product) = found {
        println!("  Found: {} (${:.2})", product.name, product.price);
    }
    println!("  Items checked: {} out of 1000", checks);
    println!("  ✅ Stopped immediately after finding first match!\n");

    // ============================================================================
    // DEMO 7: Composition - Build Queries Incrementally
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 7: Composable queries");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building base query...");
    let base_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Created base query (not executed)\n");

    println!("  Adding price filter...");
    let refined_query = base_query
        .where_(Product::price_r(), |&price| price > 100.0);

    println!("  Still not executed...\n");

    println!("  Adding stock filter and limiting...");
    let final_query = refined_query
        .where_(Product::stock_r(), |&stock| stock > 5)
        .take_lazy(10);

    println!("  Still not executed...\n");

    println!("  Executing...");
    let results: Vec<_> = final_query.collect();
    println!("  ✅ Executed once with all filters: Found {} items\n", results.len());

    // ============================================================================
    // DEMO 8: For Loop - Natural Iteration
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 8: Use in for loops");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Iterating over filtered products...");
    let mut count = 0;
    for product in LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
    {
        println!("  • {}: ${:.2}", product.name, product.price);
        count += 1;
    }
    println!("  ✅ Processed {} items lazily\n", count);

    // ============================================================================
    // DEMO 9: Performance Comparison
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 9: Performance benefit demonstration");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first expensive item from 1000 products\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);
    
    println!("Without lazy (hypothetical - check all, then take first):");
    println!("  Would check: 1000 items");
    println!("  Would find: ~300 matching items");
    println!("  Would return: 1 item");
    println!("  Wasted work: 299 items processed unnecessarily\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);
    
    println!("With lazy evaluation:");
    let _first = LazyQuery::new(&products)
        .where_(Product::price_r(), |p| expensive_check(p))
        .first();

    let ops = EXPENSIVE_OPERATIONS.load(Ordering::SeqCst);
    println!("  Checked: {} items", ops);
    println!("  Found: 1 item");
    println!("  Wasted work: 0 items");
    println!("  ✅ Efficiency gain: {}x faster!", 1000 / ops.max(1));

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Lazy Evaluation Benefits                                     ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Deferred Execution:");
    println!("   • No work until results needed");
    println!("   • Can build complex queries without performance cost\n");

    println!("✅ Early Termination:");
    println!("   • .take(n) stops after n items");
    println!("   • .first() stops after 1 item");
    println!("   • .any() stops after first match");
    println!("   • Massive performance win for large datasets\n");

    println!("✅ Iterator Fusion:");
    println!("   • Multiple filters combined into one pass");
    println!("   • Rust compiler optimizes chained operations");
    println!("   • No intermediate allocations\n");

    println!("✅ Composable:");
    println!("   • Build queries incrementally");
    println!("   • Reuse query fragments");
    println!("   • Clean separation of query building vs execution\n");

    println!("✅ Zero Overhead:");
    println!("   • Compiles to same code as manual loops");
    println!("   • No runtime cost for abstraction");
    println!("   • Pay only for what you use\n");

    println!("✓ Lazy evaluation demo complete!\n");
}

examples/arc_rwlock_hashmap.rs (line 106)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Arc<RwLock<T>> HashMap Lazy Query Demo                         ║");
    println!("║  Thread-safe shared data with lazy evaluation                   ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    let product_map = create_sample_data();
    println!("Created product catalog:");
    println!("  Total products: {}", product_map.len());
    println!("  Keys: {:?}\n", product_map.keys().take(3).collect::<Vec<_>>());

    // Extract products for querying
    let products = extract_products(&product_map);
    println!("Extracted {} products from Arc<RwLock<Product>>\n", products.len());

    // ============================================================================
    // LAZY OPERATION 1: where_ - Lazy Filtering
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 1: where_ (filtering)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building filtered query (nothing executes yet)...");
    let electronics_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::active_r(), |&active| active)
        .where_(Product::stock_r(), |&stock| stock > 20);

    println!("  ✅ Query built (deferred execution)\n");

    println!("Collecting results (executes now)...");
    let electronics: Vec<_> = electronics_query.collect();
    println!("  Found {} electronics in stock", electronics.len());
    for p in &electronics {
        println!("    • {}: {} in stock", p.name, p.stock);
    }

    // ============================================================================
    // LAZY OPERATION 2: select_lazy - Lazy Projection
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 2: select_lazy (projection)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting product names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .select_lazy(Product::name_r())
        .collect();

    println!("  Furniture names ({}):", names.len());
    for name in &names {
        println!("    • {}", name);
    }

    // ============================================================================
    // LAZY OPERATION 3: take_lazy - Early Termination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 3: take_lazy (early termination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting first 3 electronics...");
    let first_3: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
        .collect();

    println!("  First 3 electronics:");
    for (i, p) in first_3.iter().enumerate() {
        println!("    {}. {} - ${:.2}", i + 1, p.name, p.price);
    }
    println!("  ✅ Stopped after finding 3 items!");

    // ============================================================================
    // LAZY OPERATION 4: skip_lazy - Pagination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 4: skip_lazy (pagination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting page 2 (skip 3, take 3)...");
    let page_2: Vec<_> = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .skip_lazy(3)
        .take_lazy(3)
        .collect();

    println!("  Page 2 items:");
    for (i, p) in page_2.iter().enumerate() {
        println!("    {}. {}", i + 4, p.name);
    }

    // ============================================================================
    // LAZY OPERATION 5: first - Short-Circuit Search
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 5: first (short-circuit)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Finding first expensive item (>$1000)...");
    let expensive = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0)
        .first();

    match expensive {
        Some(p) => println!("  Found: {} - ${:.2}", p.name, p.price),
        None => println!("  Not found"),
    }
    println!("  ✅ Stopped at first match!");

    // ============================================================================
    // LAZY OPERATION 6: any - Existence Check
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 6: any (existence check)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Checking if any furniture exists...");
    let has_furniture = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .any();

    println!("  Has furniture: {}", has_furniture);
    println!("  ✅ Stopped immediately after finding first match!");

    // ============================================================================
    // LAZY OPERATION 7: count - Count Matching Items
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 7: count");
    println!("═══════════════════════════════════════════════════════════════\n");

    let electronics_count = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .count();

    println!("  Electronics count: {}", electronics_count);

    // ============================================================================
    // LAZY OPERATION 8: sum_by - Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 8: sum_by (aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_value: f64 = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .sum_by(Product::price_r());

    println!("  Total electronics value: ${:.2}", total_value);

    // ============================================================================
    // LAZY OPERATION 9: avg_by - Average
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 9: avg_by");
    println!("═══════════════════════════════════════════════════════════════\n");

    let avg_price = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .avg_by(Product::price_r())
        .unwrap_or(0.0);

    println!("  Average furniture price: ${:.2}", avg_price);

    // ============================================================================
    // LAZY OPERATION 10: min_by_float / max_by_float
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 10: min_by_float / max_by_float");
    println!("═══════════════════════════════════════════════════════════════\n");

    let min_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .min_by_float(Product::price_r())
        .unwrap_or(0.0);

    let max_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .max_by_float(Product::price_r())
        .unwrap_or(0.0);

    println!("  Price range for active products:");
    println!("    Min: ${:.2}", min_price);
    println!("    Max: ${:.2}", max_price);

    // ============================================================================
    // LAZY OPERATION 11: find - Find with Predicate
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 11: find (with predicate)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let high_rated = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .find(|item| item.rating > 4.7);

    if let Some(product) = high_rated {
        println!("  First highly-rated electronic:");
        println!("    {}: Rating {:.1}", product.name, product.rating);
    }

    // ============================================================================
    // LAZY OPERATION 12: for_each - Iteration
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 12: for_each (iteration)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  Low stock alerts:");
    LazyQuery::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .for_each(|product| {
            println!("    ⚠️  {}: Only {} in stock", product.name, product.stock);
        });

    // ============================================================================
    // LAZY OPERATION 13: fold - Custom Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 14: fold (custom aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_inventory_value = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .fold(0.0, |acc, product| {
            acc + (product.price * product.stock as f64)
        });

    println!("  Total inventory value: ${:.2}", total_inventory_value);

    // ============================================================================
    // LAZY OPERATION 14: all_match - Validation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 15: all_match (validation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let all_priced = LazyQuery::new(&products)
        .all_match(|item| item.price > 0.0);

    println!("  All products have valid prices: {}", all_priced);

    // ============================================================================
    // LAZY OPERATION 15: into_iter - For Loop
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 16: into_iter (for loop)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  High-value products (>$300):");
    for product in LazyQuery::new(&products)
        .where_(Product::price_r(), |&p| p > 300.0)
        .take_lazy(5)
    {
        println!("    • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // LAZY OPERATION 16: map_items - Transform
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 17: map_items (transformation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let price_tags: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .map_items(|p| format!("{}: ${:.2}", p.name, p.price))
        .take(5)
        .collect();

    println!("  Electronics price tags:");
    for tag in &price_tags {
        println!("    • {}", tag);
    }

    // ============================================================================
    // COMPLEX EXAMPLE: Multi-Stage Lazy Pipeline
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Multi-stage lazy pipeline");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building complex query:");
    println!("  1. Filter by category (Electronics)");
    println!("  2. Filter by price range ($50-$500)");
    println!("  3. Filter by rating (>4.5)");
    println!("  4. Select names");
    println!("  5. Take first 3");
    println!();

    let results: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p >= 50.0 && p <= 500.0)
        .where_(Product::rating_r(), |&r| r > 4.5)
        .select_lazy(Product::name_r())
        .take(3)
        .collect();

    println!("  Results:");
    for (i, name) in results.iter().enumerate() {
        println!("    {}. {}", i + 1, name);
    }
    println!("  ✅ All operations fused and executed lazily!");

    // ============================================================================
    // THREAD-SAFE UPDATES WITH RWLOCK
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Bonus: Thread-safe updates with RwLock");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Update a product through the Arc<RwLock>
    if let Some(product_arc) = product_map.get("PROD-002") {
        println!("Updating PROD-002 stock...");
        
        // Write lock for mutation
        if let Ok(mut product) = product_arc.write() {
            let old_stock = product.stock;
            product.stock = 25;
            println!("  Stock updated: {} → {}", old_stock, product.stock);
        }
    }

    // Query again to see the update
    let updated_products = extract_products(&product_map);
    let mouse = LazyQuery::new(&updated_products)
        .find(|p| p.id == 2);

    if let Some(product) = mouse {
        println!("  Verified update: {} now has {} in stock", product.name, product.stock);
    }

    // ============================================================================
    // PRACTICAL EXAMPLE: Price Analysis by Category
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Practical Example: Price analysis by category");
    println!("═══════════════════════════════════════════════════════════════\n");

    let categories = vec!["Electronics", "Furniture"];

    for category in categories {
        println!("  {} Statistics:", category);
        
        // Filter products by category first
        let cat_products: Vec<Product> = products.iter()
            .filter(|p| p.category == category)
            .cloned()
            .collect();

        let count = LazyQuery::new(&cat_products).count();
        let total = LazyQuery::new(&cat_products).sum_by(Product::price_r());
        let avg = LazyQuery::new(&cat_products).avg_by(Product::price_r()).unwrap_or(0.0);
        let min = LazyQuery::new(&cat_products).min_by_float(Product::price_r()).unwrap_or(0.0);
        let max = LazyQuery::new(&cat_products).max_by_float(Product::price_r()).unwrap_or(0.0);

        println!("    Count: {}", count);
        println!("    Total: ${:.2}", total);
        println!("    Average: ${:.2}", avg);
        println!("    Range: ${:.2} - ${:.2}\n", min, max);
    }

    // ============================================================================
    // COMBINING WITH HASHMAP OPERATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("HashMap Integration: Query by key patterns");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Filter HashMap by key pattern
    let electronics_keys: Vec<String> = product_map
        .iter()
        .filter(|(_key, value)| {
            // Read the value to check category
            if let Ok(guard) = value.read() {
                guard.category == "Electronics"
            } else {
                false
            }
        })
        .map(|(key, _value)| key.clone())
        .collect();

    println!("  Electronics product IDs:");
    for key in electronics_keys.iter().take(5) {
        println!("    • {}", key);
    }

    // ============================================================================
    // PERFORMANCE DEMONSTRATION
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Performance: Lazy vs Eager comparison");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first product with rating > 4.7 from {} products\n", products.len());

    println!("  Eager approach (hypothetical):");
    println!("    - Filter all {} products", products.len());
    println!("    - Collect filtered results");
    println!("    - Take first item");
    println!("    - Wasted work: Check all items\n");

    println!("  Lazy approach (actual):");
    let _first_rated = LazyQuery::new(&products)
        .where_(Product::rating_r(), |&r| r > 4.7)
        .first();
    println!("    - Starts checking products");
    println!("    - Stops at first match");
    println!("    - ✅ Early termination - checks ~3-5 items only!");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: All Lazy Operations Demonstrated                      ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Lazy Query Operations:");
    println!("   1. ✅ where_ - Lazy filtering");
    println!("   2. ✅ select_lazy - Lazy projection");
    println!("   3. ✅ take_lazy - Early termination");
    println!("   4. ✅ skip_lazy - Pagination");
    println!("   5. ✅ first - Short-circuit search");
    println!("   6. ✅ any - Existence check (short-circuit)");
    println!("   7. ✅ count - Count items");
    println!("   8. ✅ sum_by - Sum aggregation");
    println!("   9. ✅ avg_by - Average aggregation");
    println!("   10. ✅ min_by_float - Minimum value");
    println!("   11. ✅ max_by_float - Maximum value");
    println!("   12. ✅ find - Find with predicate (short-circuit)");
    println!("   13. ✅ for_each - Iteration");
    println!("   14. ✅ fold - Custom aggregation");
    println!("   15. ✅ all_match - Validation (short-circuit)");
    println!("   16. ✅ into_iter - For loop support");
    println!("   17. ✅ map_items - Transformation\n");

    println!("✅ Arc<RwLock<T>> Benefits:");
    println!("   • Thread-safe shared access");
    println!("   • Interior mutability");
    println!("   • Multiple readers, single writer");
    println!("   • Reference counting (Arc)");
    println!("   • Can be queried after extracting data\n");

    println!("✅ HashMap<K, Arc<RwLock<V>>> Benefits:");
    println!("   • Fast key-based lookup");
    println!("   • Thread-safe value access");
    println!("   • Can query all values");
    println!("   • Can filter by key patterns");
    println!("   • Perfect for shared state/caches\n");

    println!("🎯 Use Cases:");
    println!("   • Shared product catalogs");
    println!("   • User session stores");
    println!("   • Configuration caches");
    println!("   • Real-time inventory systems");
    println!("   • Multi-threaded data processing");
    println!("   • Web server state management\n");

    println!("✓ Arc<RwLock<T>> HashMap with all lazy operations demo complete!\n");
}

pub fn take_lazy( self, n: usize, ) -> LazyQuery<'a, T, impl Iterator<Item = &'a T> + 'a>

where I: 'a,

Takes at most n items (lazy).

Example

let first_10: Vec<_> = LazyQuery::new(&products)
    .take_lazy(10)
    .collect();

Examples found in repository

examples/derive_and_ext.rs (line 89)

fn main() {
    println!("Derive Macros and Extension Traits Example");
    println!("===========================================\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. Using Extension Trait - Direct .query() on Vec");
    println!("   Query: products.query().where_(price > 100).all()");
    
    let query = products
        .query()
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in &expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. Using Extension Trait - Direct .lazy_query() on Vec");
    println!("   Query: products.lazy_query().where_(stock < 10).collect()");
    
    let low_stock: Vec<_> = products
        .lazy_query()
        .where_(Product::stock_r(), |&s| s < 10)
        .collect();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in &low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. Using Extension Trait - Chained Operations");
    println!("   Query: products.lazy_query().where_(category == Electronics).take(2).select(name).collect()");
    
    let names: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(2)
        .select_lazy(Product::name_r())
        .collect();
    
    println!("   First 2 electronics:");
    for name in &names {
        println!("   - {}", name);
    }
    println!();

    println!("4. Using QueryBuilder Derive - Static Methods");
    println!("   Query: Product::query(&products).where_(price > 50).count()");
    
    let query4 = Product::query(&products)
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query4.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("5. Using QueryBuilder Derive - Lazy Static Methods");
    println!("   Query: Product::lazy_query(&products).first()");
    
    if let Some(first) = Product::lazy_query(&products).first() {
        println!("   First product: {} (${:.2})", first.name, first.price);
    }
    println!();

    println!("6. Complex Chain with Extension Trait");
    println!("   Query: products.lazy_query()");
    println!("          .where_(category == Electronics)");
    println!("          .where_(price < 500)");
    println!("          .map(|p| format!(\"{{}} - ${{:.2}}\", p.name, p.price))");
    println!("          .collect()");
    
    let formatted: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .map_items(|p| format!("{} - ${:.2}", p.name, p.price))
        .collect();
    
    println!("   Affordable electronics:");
    for item in &formatted {
        println!("   - {}", item);
    }
    println!();

    println!("7. Aggregation with Extension Trait");
    println!("   Query: products.lazy_query().sum_by(Product::stock())");
    
    let total_stock = products
        .lazy_query()
        .sum_by(Product::stock_r());
    
    println!("   Total stock across all products: {}", total_stock);
    println!();

    println!("8. Find with Extension Trait");
    println!("   Query: products.lazy_query().find(|p| p.name.contains(\"Chair\"))");
    
    if let Some(chair) = products.lazy_query().find(|p| p.name.contains("Chair")) {
        println!("   Found: {} in {}", chair.name, chair.category);
    }
    println!();

    println!("9. Early Termination with Extension Trait");
    println!("   Query: products.lazy_query().where_(price > 1000).any()");
    
    let has_luxury = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p > 1000.0)
        .any();
    
    println!("   Has products over $1000: {}", has_luxury);
    println!();

    println!("10. Slice Extension Trait");
    println!("    Query: (&products[..]).lazy_query().count()");
    
    let slice_count = (&products[..])
        .lazy_query()
        .count();
    
    println!("    Count from slice: {}", slice_count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ Extension trait QueryExt adds .query() and .lazy_query() to containers");
    println!("✓ Derive macro QueryBuilder adds static methods Product::query() and Product::lazy_query()");
    println!("✓ Both approaches provide the same query functionality");
    println!("✓ Extension trait is more ergonomic: products.query() vs Query::new(&products)");
    println!("✓ All iterator optimizations (fusion, early termination) still apply");
}

examples/lazy_evaluation.rs (line 98)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Lazy Query Evaluation Demo                                   ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    let products = create_products();
    println!("Created {} products\n", products.len());

    // ============================================================================
    // DEMO 1: Lazy Execution - Nothing Happens Until .collect()
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 1: Lazy execution - deferred until needed");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Building query (should execute nothing)...");
    let lazy_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            cat == "Electronics"
        });

    let evals_after_build = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Filter evaluations after building query: {}", evals_after_build);
    
    if evals_after_build == 0 {
        println!("  ✅ Confirmed: Query is lazy! Nothing executed yet.\n");
    }

    println!("Collecting results (now it executes)...");
    let results: Vec<_> = lazy_query.collect();

    let evals_after_collect = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Filter evaluations after collecting: {}", evals_after_collect);
    println!("  Results found: {}", results.len());
    println!("  ✅ Query executed exactly once, when needed!\n");

    // ============================================================================
    // DEMO 2: Early Termination - Stops as Soon as Enough Items Found
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 2: Early termination with .take()");
    println!("═══════════════════════════════════════════════════════════════\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);

    println!("Finding first 5 expensive items from 1000 products...");
    let first_5: Vec<_> = LazyQuery::new(&products)
        .where_(Product::price_r(), |p| expensive_check(p))
        .take_lazy(5)
        .collect();

    let ops = EXPENSIVE_OPERATIONS.load(Ordering::SeqCst);
    println!("  Found: {} items", first_5.len());
    println!("  Expensive operations performed: {}", ops);
    println!("  Items NOT checked: {} (stopped early!)", 1000 - ops);
    
    if ops < 1000 {
        println!("  ✅ Early termination worked! Didn't check all 1000 items.\n");
    }

    // ============================================================================
    // DEMO 3: Iterator Fusion - Rust Optimizes Chained Operations
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 3: Iterator fusion - chained operations optimized");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Chaining multiple operations...");
    let chained_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price > 200.0)
        .where_(Product::stock_r(), |&stock| stock > 10)
        .take_lazy(10);

    println!("  Built query with 3 filters + take(10)");
    println!("  ✅ No execution yet - all operations fused into one iterator\n");

    let results: Vec<_> = chained_query.collect();
    println!("  Executed: Found {} items", results.len());
    println!("  ✅ All filters applied in single pass!\n");

    // ============================================================================
    // DEMO 4: Lazy Projection - Only Extract What You Need
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 4: Lazy projection");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .select_lazy(Product::name_r())
        .take(5)  // Only process until we have 5
        .collect();

    println!("  Selected {} names", names.len());
    println!("  ✅ Only evaluated until 5 names found!\n");

    // ============================================================================
    // DEMO 5: Lazy Aggregation - Short-Circuit When Possible
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 5: Short-circuit with .any()");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Checking if ANY electronics exist (1000 items to search)...");
    let exists = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            cat == "Electronics"
        })
        .any();

    let checks = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Result: {}", exists);
    println!("  Items checked: {} out of 1000", checks);
    println!("  Items skipped: {} (short-circuited!)", 1000 - checks);
    
    if checks < 1000 {
        println!("  ✅ Short-circuit worked! Stopped as soon as first match found.\n");
    }

    // ============================================================================
    // DEMO 6: Lazy Find - Stops at First Match
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 6: .find() stops at first match");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Finding first product with price > 500...");
    let found = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            price > 500.0
        })
        .first();

    let checks = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    if let Some(product) = found {
        println!("  Found: {} (${:.2})", product.name, product.price);
    }
    println!("  Items checked: {} out of 1000", checks);
    println!("  ✅ Stopped immediately after finding first match!\n");

    // ============================================================================
    // DEMO 7: Composition - Build Queries Incrementally
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 7: Composable queries");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building base query...");
    let base_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Created base query (not executed)\n");

    println!("  Adding price filter...");
    let refined_query = base_query
        .where_(Product::price_r(), |&price| price > 100.0);

    println!("  Still not executed...\n");

    println!("  Adding stock filter and limiting...");
    let final_query = refined_query
        .where_(Product::stock_r(), |&stock| stock > 5)
        .take_lazy(10);

    println!("  Still not executed...\n");

    println!("  Executing...");
    let results: Vec<_> = final_query.collect();
    println!("  ✅ Executed once with all filters: Found {} items\n", results.len());

    // ============================================================================
    // DEMO 8: For Loop - Natural Iteration
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 8: Use in for loops");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Iterating over filtered products...");
    let mut count = 0;
    for product in LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
    {
        println!("  • {}: ${:.2}", product.name, product.price);
        count += 1;
    }
    println!("  ✅ Processed {} items lazily\n", count);

    // ============================================================================
    // DEMO 9: Performance Comparison
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 9: Performance benefit demonstration");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first expensive item from 1000 products\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);
    
    println!("Without lazy (hypothetical - check all, then take first):");
    println!("  Would check: 1000 items");
    println!("  Would find: ~300 matching items");
    println!("  Would return: 1 item");
    println!("  Wasted work: 299 items processed unnecessarily\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);
    
    println!("With lazy evaluation:");
    let _first = LazyQuery::new(&products)
        .where_(Product::price_r(), |p| expensive_check(p))
        .first();

    let ops = EXPENSIVE_OPERATIONS.load(Ordering::SeqCst);
    println!("  Checked: {} items", ops);
    println!("  Found: 1 item");
    println!("  Wasted work: 0 items");
    println!("  ✅ Efficiency gain: {}x faster!", 1000 / ops.max(1));

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Lazy Evaluation Benefits                                     ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Deferred Execution:");
    println!("   • No work until results needed");
    println!("   • Can build complex queries without performance cost\n");

    println!("✅ Early Termination:");
    println!("   • .take(n) stops after n items");
    println!("   • .first() stops after 1 item");
    println!("   • .any() stops after first match");
    println!("   • Massive performance win for large datasets\n");

    println!("✅ Iterator Fusion:");
    println!("   • Multiple filters combined into one pass");
    println!("   • Rust compiler optimizes chained operations");
    println!("   • No intermediate allocations\n");

    println!("✅ Composable:");
    println!("   • Build queries incrementally");
    println!("   • Reuse query fragments");
    println!("   • Clean separation of query building vs execution\n");

    println!("✅ Zero Overhead:");
    println!("   • Compiles to same code as manual loops");
    println!("   • No runtime cost for abstraction");
    println!("   • Pay only for what you use\n");

    println!("✓ Lazy evaluation demo complete!\n");
}

examples/macro_helpers.rs (line 329)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Macro Helpers Demo - Reducing Boilerplate                    ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    let products = create_products();

    // ============================================================================
    // EXAMPLE 1: Simple Collection
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 1: collect_lazy! - Simple collection");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let results: Vec<_> = LazyQuery::new(&products).collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let results = collect_lazy!(&products);");
    println!("```\n");

    let results = collect_lazy!(&products);
    println!("Result: {} products collected\n", results.len());

    // ============================================================================
    // EXAMPLE 2: Filter and Collect
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 2: filter_collect! - Filter and collect");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let electronics: Vec<_> = LazyQuery::new(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Electronics\")");
    println!("    .collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let electronics = filter_collect!(");
    println!("    &products,");
    println!("    Product::category_r(),");
    println!("    |cat| cat == \"Electronics\"");
    println!(");");
    println!("```\n");

    let electronics = filter_collect!(
        &products,
        Product::category_r(),
        |cat| cat == "Electronics"
    );
    println!("Result: {} electronics\n", electronics.len());

    // ============================================================================
    // EXAMPLE 3: Count with Filter
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 3: count_where! - Count with filter");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let count = LazyQuery::new(&products)");
    println!("    .where_(Product::stock_r(), |&s| s > 0)");
    println!("    .count();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let count = count_where!(&products, Product::stock_r(), |&s| s > 0);");
    println!("```\n");

    let count = count_where!(&products, Product::stock_r(), |&s| s > 0);
    println!("Result: {} products in stock\n", count);

    // ============================================================================
    // EXAMPLE 4: Find First
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 4: find_first! - Find first matching item");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let found = LazyQuery::new(&products)");
    println!("    .where_(Product::price_r(), |&p| p > 500.0)");
    println!("    .first();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let found = find_first!(&products, Product::price_r(), |&p| p > 500.0);");
    println!("```\n");

    let found = find_first!(&products, Product::price_r(), |&p| p > 500.0);
    if let Some(p) = found {
        println!("Result: Found {} at ${:.2}\n", p.name, p.price);
    }

    // ============================================================================
    // EXAMPLE 5: Existence Check
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 5: exists_where! - Check if any item matches");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let has_furniture = LazyQuery::new(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Furniture\")");
    println!("    .any();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let has_furniture = exists_where!(");
    println!("    &products,");
    println!("    Product::category_r(),");
    println!("    |cat| cat == \"Furniture\"");
    println!(");");
    println!("```\n");

    let has_furniture = exists_where!(
        &products,
        Product::category_r(),
        |cat| cat == "Furniture"
    );
    println!("Result: Has furniture = {}\n", has_furniture);

    // ============================================================================
    // EXAMPLE 6: Pagination
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 6: paginate! - Quick pagination");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let page_2: Vec<_> = LazyQuery::new(&products)");
    println!("    .skip_lazy(1 * 2)  // page * size");
    println!("    .take_lazy(2)");
    println!("    .collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let page_2 = paginate!(&products, page: 1, size: 2);");
    println!("```\n");

    let page_2 = paginate!(&products, page: 1, size: 2);
    println!("Result: Page 2 has {} items\n", page_2.len());

    // ============================================================================
    // EXAMPLE 7: Sum with Filter
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 7: sum_where! - Sum with filter");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let total: f64 = LazyQuery::new(&products)");
    println!("    .where_(Product::active_r(), |&a| a)");
    println!("    .sum_by(Product::price_r());");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let total = sum_where!(&products, Product::price_r(), Product::active_r(), |&a| a);");
    println!("```\n");

    let total = sum_where!(&products, Product::price_r(), Product::active_r(), |&a| a);
    println!("Result: Total active products value = ${:.2}\n", total);

    // ============================================================================
    // EXAMPLE 8: Average with Filter
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 8: avg_where! - Average with filter");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let avg = LazyQuery::new(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Electronics\")");
    println!("    .avg_by(Product::price_r())");
    println!("    .unwrap_or(0.0);");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let avg = avg_where!(");
    println!("    &products,");
    println!("    Product::price_r(),");
    println!("    Product::category_r(),");
    println!("    |cat| cat == \"Electronics\"");
    println!(").unwrap_or(0.0);");
    println!("```\n");

    let avg = avg_where!(
        &products,
        Product::price_r(),
        Product::category_r(),
        |cat| cat == "Electronics"
    ).unwrap_or(0.0);
    println!("Result: Average electronics price = ${:.2}\n", avg);

    // ============================================================================
    // EXAMPLE 9: Select All
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 9: select_all! - Select field from all items");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let names: Vec<String> = LazyQuery::new(&products)");
    println!("    .select_lazy(Product::name_r())");
    println!("    .collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let names = select_all!(&products, Product::name_r());");
    println!("```\n");

    let names: Vec<String> = select_all!(&products, Product::name_r());
    println!("Result: {} product names\n", names.len());

    // ============================================================================
    // EXAMPLE 10: Select with Filter
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 10: select_where! - Select field with filter");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let furniture_names: Vec<String> = LazyQuery::new(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Furniture\")");
    println!("    .select_lazy(Product::name_r())");
    println!("    .collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let furniture_names = select_where!(");
    println!("    &products,");
    println!("    Product::name_r(),");
    println!("    Product::category_r(),");
    println!("    |cat| cat == \"Furniture\"");
    println!(");");
    println!("```\n");

    let furniture_names: Vec<String> = select_where!(
        &products,
        Product::name_r(),
        Product::category_r(),
        |cat| cat == "Furniture"
    );
    println!("Result: {} furniture items\n", furniture_names.len());

    // ============================================================================
    // COMPARISON: Complex Query
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Before & After");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Filter electronics, under $500, in stock, get first 5\n");

    println!("❌ WITHOUT MACROS (13 lines):");
    println!("```rust");
    println!("let results: Vec<_> = LazyQuery::new(&products)");
    println!("    .where_(");
    println!("        Product::category_r(),");
    println!("        |cat| cat == \"Electronics\"");
    println!("    )");
    println!("    .where_(Product::price_r(), |&p| p < 500.0)");
    println!("    .where_(Product::stock_r(), |&s| s > 0)");
    println!("    .take_lazy(5)");
    println!("    .collect();");
    println!("```\n");

    // Actual verbose version
    let verbose_results: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .where_(Product::stock_r(), |&s| s > 0)
        .take_lazy(5)
        .collect();

    println!("✅ WITH MACROS (Shorter, but still need multiple filters):");
    println!("```rust");
    println!("let results = lazy_query!(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Electronics\")");
    println!("    .where_(Product::price_r(), |&p| p < 500.0)");
    println!("    .where_(Product::stock_r(), |&s| s > 0)");
    println!("    .take_lazy(5)");
    println!("    .collect();");
    println!("```\n");

    let macro_results = lazy_query!(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .where_(Product::stock_r(), |&s| s > 0)
        .take_lazy(5)
        .collect();

    println!("Both approaches found {} items ✅\n", verbose_results.len());
    assert_eq!(verbose_results.len(), macro_results.len());

    // ============================================================================
    // CODE REDUCTION METRICS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Code Reduction Metrics");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Pattern Comparisons:\n");

    println!("  1. Simple collect:");
    println!("     Before: LazyQuery::new(&data).collect()");
    println!("     After:  collect_lazy!(&data)");
    println!("     Saved:  ~20 characters\n");

    println!("  2. Filter + collect:");
    println!("     Before: LazyQuery::new(&data).where_(...).collect()");
    println!("     After:  filter_collect!(&data, field, pred)");
    println!("     Saved:  ~35 characters\n");

    println!("  3. Count with filter:");
    println!("     Before: LazyQuery::new(&data).where_(...).count()");
    println!("     After:  count_where!(&data, field, pred)");
    println!("     Saved:  ~30 characters\n");

    println!("  4. Pagination:");
    println!("     Before: LazyQuery::new(&data).skip_lazy(p*s).take_lazy(s).collect()");
    println!("     After:  paginate!(&data, page: p, size: s)");
    println!("     Saved:  ~45 characters\n");

    println!("  5. Sum with filter:");
    println!("     Before: LazyQuery::new(&data).where_(...).sum_by(...)");
    println!("     After:  sum_where!(&data, sum_field, filter_field, pred)");
    println!("     Saved:  ~25 characters\n");

    // ============================================================================
    // ALL MACRO DEMONSTRATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("All Available Macros - Quick Reference");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("1. lazy_query!(&data)");
    let _q1 = lazy_query!(&products);
    println!("   → LazyQuery::new(&data)\n");

    println!("2. query!(&data)");
    let _q2 = query!(&products);
    println!("   → Query::new(&data)\n");

    println!("3. collect_lazy!(&data)");
    let _r3 = collect_lazy!(&products);
    println!("   → LazyQuery::new(&data).collect()\n");

    println!("4. filter_collect!(&data, field, pred)");
    let _r4 = filter_collect!(&products, Product::active_r(), |&a| a);
    println!("   → LazyQuery::new(&data).where_(field, pred).collect()\n");

    println!("5. count_where!(&data, field, pred)");
    let _r5 = count_where!(&products, Product::active_r(), |&a| a);
    println!("   → LazyQuery::new(&data).where_(field, pred).count()\n");

    println!("6. find_first!(&data, field, pred)");
    let _r6 = find_first!(&products, Product::id_r(), |&id| id == 1);
    println!("   → LazyQuery::new(&data).where_(field, pred).first()\n");

    println!("7. exists_where!(&data, field, pred)");
    let _r7 = exists_where!(&products, Product::active_r(), |&a| a);
    println!("   → LazyQuery::new(&data).where_(field, pred).any()\n");

    println!("8. paginate!(&data, page: p, size: s)");
    let _r8 = paginate!(&products, page: 0, size: 3);
    println!("   → LazyQuery::new(&data).skip_lazy(p*s).take_lazy(s).collect()\n");

    println!("9. sum_where!(&data, sum_field, filter_field, pred)");
    let _r9 = sum_where!(&products, Product::price_r(), Product::active_r(), |&a| a);
    println!("   → LazyQuery::new(&data).where_(filter_field, pred).sum_by(sum_field)\n");

    println!("10. avg_where!(&data, avg_field, filter_field, pred)");
    let _r10 = avg_where!(&products, Product::price_r(), Product::active_r(), |&a| a);
    println!("    → LazyQuery::new(&data).where_(filter_field, pred).avg_by(avg_field)\n");

    println!("11. select_all!(&data, field)");
    let _r11: Vec<String> = select_all!(&products, Product::name_r());
    println!("    → LazyQuery::new(&data).select_lazy(field).collect()\n");

    println!("12. select_where!(&data, select_field, filter_field, pred)");
    let _r12: Vec<String> = select_where!(&products, Product::name_r(), Product::active_r(), |&a| a);
    println!("    → LazyQuery::new(&data).where_(filter, pred).select_lazy(field).collect()\n");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("╔════════════════════════════════════════════════════════════════╗");
    println!("║  Summary                                                       ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ 12 helper macros provided:");
    println!("   • lazy_query! - Create LazyQuery");
    println!("   • query! - Create Query");
    println!("   • collect_lazy! - Quick collect");
    println!("   • filter_collect! - Filter and collect");
    println!("   • count_where! - Count with filter");
    println!("   • find_first! - Find first match");
    println!("   • exists_where! - Existence check");
    println!("   • paginate! - Easy pagination");
    println!("   • sum_where! - Sum with filter");
    println!("   • avg_where! - Average with filter");
    println!("   • select_all! - Select all");
    println!("   • select_where! - Select with filter\n");

    println!("📊 Benefits:");
    println!("   • Less typing (20-45 characters saved per operation)");
    println!("   • More readable code");
    println!("   • Common patterns encapsulated");
    println!("   • Same performance (zero-cost abstraction)");
    println!("   • Type-safe (compile-time checked)\n");

    println!("💡 When to use:");
    println!("   • Use macros for simple, common patterns");
    println!("   • Use full API for complex queries");
    println!("   • Mix and match as needed\n");

    println!("✓ Macro helpers demo complete!\n");
}

examples/arc_rwlock_hashmap.rs (line 124)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Arc<RwLock<T>> HashMap Lazy Query Demo                         ║");
    println!("║  Thread-safe shared data with lazy evaluation                   ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    let product_map = create_sample_data();
    println!("Created product catalog:");
    println!("  Total products: {}", product_map.len());
    println!("  Keys: {:?}\n", product_map.keys().take(3).collect::<Vec<_>>());

    // Extract products for querying
    let products = extract_products(&product_map);
    println!("Extracted {} products from Arc<RwLock<Product>>\n", products.len());

    // ============================================================================
    // LAZY OPERATION 1: where_ - Lazy Filtering
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 1: where_ (filtering)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building filtered query (nothing executes yet)...");
    let electronics_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::active_r(), |&active| active)
        .where_(Product::stock_r(), |&stock| stock > 20);

    println!("  ✅ Query built (deferred execution)\n");

    println!("Collecting results (executes now)...");
    let electronics: Vec<_> = electronics_query.collect();
    println!("  Found {} electronics in stock", electronics.len());
    for p in &electronics {
        println!("    • {}: {} in stock", p.name, p.stock);
    }

    // ============================================================================
    // LAZY OPERATION 2: select_lazy - Lazy Projection
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 2: select_lazy (projection)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting product names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .select_lazy(Product::name_r())
        .collect();

    println!("  Furniture names ({}):", names.len());
    for name in &names {
        println!("    • {}", name);
    }

    // ============================================================================
    // LAZY OPERATION 3: take_lazy - Early Termination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 3: take_lazy (early termination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting first 3 electronics...");
    let first_3: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
        .collect();

    println!("  First 3 electronics:");
    for (i, p) in first_3.iter().enumerate() {
        println!("    {}. {} - ${:.2}", i + 1, p.name, p.price);
    }
    println!("  ✅ Stopped after finding 3 items!");

    // ============================================================================
    // LAZY OPERATION 4: skip_lazy - Pagination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 4: skip_lazy (pagination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting page 2 (skip 3, take 3)...");
    let page_2: Vec<_> = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .skip_lazy(3)
        .take_lazy(3)
        .collect();

    println!("  Page 2 items:");
    for (i, p) in page_2.iter().enumerate() {
        println!("    {}. {}", i + 4, p.name);
    }

    // ============================================================================
    // LAZY OPERATION 5: first - Short-Circuit Search
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 5: first (short-circuit)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Finding first expensive item (>$1000)...");
    let expensive = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0)
        .first();

    match expensive {
        Some(p) => println!("  Found: {} - ${:.2}", p.name, p.price),
        None => println!("  Not found"),
    }
    println!("  ✅ Stopped at first match!");

    // ============================================================================
    // LAZY OPERATION 6: any - Existence Check
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 6: any (existence check)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Checking if any furniture exists...");
    let has_furniture = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .any();

    println!("  Has furniture: {}", has_furniture);
    println!("  ✅ Stopped immediately after finding first match!");

    // ============================================================================
    // LAZY OPERATION 7: count - Count Matching Items
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 7: count");
    println!("═══════════════════════════════════════════════════════════════\n");

    let electronics_count = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .count();

    println!("  Electronics count: {}", electronics_count);

    // ============================================================================
    // LAZY OPERATION 8: sum_by - Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 8: sum_by (aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_value: f64 = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .sum_by(Product::price_r());

    println!("  Total electronics value: ${:.2}", total_value);

    // ============================================================================
    // LAZY OPERATION 9: avg_by - Average
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 9: avg_by");
    println!("═══════════════════════════════════════════════════════════════\n");

    let avg_price = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .avg_by(Product::price_r())
        .unwrap_or(0.0);

    println!("  Average furniture price: ${:.2}", avg_price);

    // ============================================================================
    // LAZY OPERATION 10: min_by_float / max_by_float
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 10: min_by_float / max_by_float");
    println!("═══════════════════════════════════════════════════════════════\n");

    let min_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .min_by_float(Product::price_r())
        .unwrap_or(0.0);

    let max_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .max_by_float(Product::price_r())
        .unwrap_or(0.0);

    println!("  Price range for active products:");
    println!("    Min: ${:.2}", min_price);
    println!("    Max: ${:.2}", max_price);

    // ============================================================================
    // LAZY OPERATION 11: find - Find with Predicate
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 11: find (with predicate)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let high_rated = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .find(|item| item.rating > 4.7);

    if let Some(product) = high_rated {
        println!("  First highly-rated electronic:");
        println!("    {}: Rating {:.1}", product.name, product.rating);
    }

    // ============================================================================
    // LAZY OPERATION 12: for_each - Iteration
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 12: for_each (iteration)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  Low stock alerts:");
    LazyQuery::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .for_each(|product| {
            println!("    ⚠️  {}: Only {} in stock", product.name, product.stock);
        });

    // ============================================================================
    // LAZY OPERATION 13: fold - Custom Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 14: fold (custom aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_inventory_value = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .fold(0.0, |acc, product| {
            acc + (product.price * product.stock as f64)
        });

    println!("  Total inventory value: ${:.2}", total_inventory_value);

    // ============================================================================
    // LAZY OPERATION 14: all_match - Validation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 15: all_match (validation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let all_priced = LazyQuery::new(&products)
        .all_match(|item| item.price > 0.0);

    println!("  All products have valid prices: {}", all_priced);

    // ============================================================================
    // LAZY OPERATION 15: into_iter - For Loop
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 16: into_iter (for loop)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  High-value products (>$300):");
    for product in LazyQuery::new(&products)
        .where_(Product::price_r(), |&p| p > 300.0)
        .take_lazy(5)
    {
        println!("    • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // LAZY OPERATION 16: map_items - Transform
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 17: map_items (transformation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let price_tags: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .map_items(|p| format!("{}: ${:.2}", p.name, p.price))
        .take(5)
        .collect();

    println!("  Electronics price tags:");
    for tag in &price_tags {
        println!("    • {}", tag);
    }

    // ============================================================================
    // COMPLEX EXAMPLE: Multi-Stage Lazy Pipeline
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Multi-stage lazy pipeline");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building complex query:");
    println!("  1. Filter by category (Electronics)");
    println!("  2. Filter by price range ($50-$500)");
    println!("  3. Filter by rating (>4.5)");
    println!("  4. Select names");
    println!("  5. Take first 3");
    println!();

    let results: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p >= 50.0 && p <= 500.0)
        .where_(Product::rating_r(), |&r| r > 4.5)
        .select_lazy(Product::name_r())
        .take(3)
        .collect();

    println!("  Results:");
    for (i, name) in results.iter().enumerate() {
        println!("    {}. {}", i + 1, name);
    }
    println!("  ✅ All operations fused and executed lazily!");

    // ============================================================================
    // THREAD-SAFE UPDATES WITH RWLOCK
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Bonus: Thread-safe updates with RwLock");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Update a product through the Arc<RwLock>
    if let Some(product_arc) = product_map.get("PROD-002") {
        println!("Updating PROD-002 stock...");
        
        // Write lock for mutation
        if let Ok(mut product) = product_arc.write() {
            let old_stock = product.stock;
            product.stock = 25;
            println!("  Stock updated: {} → {}", old_stock, product.stock);
        }
    }

    // Query again to see the update
    let updated_products = extract_products(&product_map);
    let mouse = LazyQuery::new(&updated_products)
        .find(|p| p.id == 2);

    if let Some(product) = mouse {
        println!("  Verified update: {} now has {} in stock", product.name, product.stock);
    }

    // ============================================================================
    // PRACTICAL EXAMPLE: Price Analysis by Category
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Practical Example: Price analysis by category");
    println!("═══════════════════════════════════════════════════════════════\n");

    let categories = vec!["Electronics", "Furniture"];

    for category in categories {
        println!("  {} Statistics:", category);
        
        // Filter products by category first
        let cat_products: Vec<Product> = products.iter()
            .filter(|p| p.category == category)
            .cloned()
            .collect();

        let count = LazyQuery::new(&cat_products).count();
        let total = LazyQuery::new(&cat_products).sum_by(Product::price_r());
        let avg = LazyQuery::new(&cat_products).avg_by(Product::price_r()).unwrap_or(0.0);
        let min = LazyQuery::new(&cat_products).min_by_float(Product::price_r()).unwrap_or(0.0);
        let max = LazyQuery::new(&cat_products).max_by_float(Product::price_r()).unwrap_or(0.0);

        println!("    Count: {}", count);
        println!("    Total: ${:.2}", total);
        println!("    Average: ${:.2}", avg);
        println!("    Range: ${:.2} - ${:.2}\n", min, max);
    }

    // ============================================================================
    // COMBINING WITH HASHMAP OPERATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("HashMap Integration: Query by key patterns");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Filter HashMap by key pattern
    let electronics_keys: Vec<String> = product_map
        .iter()
        .filter(|(_key, value)| {
            // Read the value to check category
            if let Ok(guard) = value.read() {
                guard.category == "Electronics"
            } else {
                false
            }
        })
        .map(|(key, _value)| key.clone())
        .collect();

    println!("  Electronics product IDs:");
    for key in electronics_keys.iter().take(5) {
        println!("    • {}", key);
    }

    // ============================================================================
    // PERFORMANCE DEMONSTRATION
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Performance: Lazy vs Eager comparison");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first product with rating > 4.7 from {} products\n", products.len());

    println!("  Eager approach (hypothetical):");
    println!("    - Filter all {} products", products.len());
    println!("    - Collect filtered results");
    println!("    - Take first item");
    println!("    - Wasted work: Check all items\n");

    println!("  Lazy approach (actual):");
    let _first_rated = LazyQuery::new(&products)
        .where_(Product::rating_r(), |&r| r > 4.7)
        .first();
    println!("    - Starts checking products");
    println!("    - Stops at first match");
    println!("    - ✅ Early termination - checks ~3-5 items only!");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: All Lazy Operations Demonstrated                      ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Lazy Query Operations:");
    println!("   1. ✅ where_ - Lazy filtering");
    println!("   2. ✅ select_lazy - Lazy projection");
    println!("   3. ✅ take_lazy - Early termination");
    println!("   4. ✅ skip_lazy - Pagination");
    println!("   5. ✅ first - Short-circuit search");
    println!("   6. ✅ any - Existence check (short-circuit)");
    println!("   7. ✅ count - Count items");
    println!("   8. ✅ sum_by - Sum aggregation");
    println!("   9. ✅ avg_by - Average aggregation");
    println!("   10. ✅ min_by_float - Minimum value");
    println!("   11. ✅ max_by_float - Maximum value");
    println!("   12. ✅ find - Find with predicate (short-circuit)");
    println!("   13. ✅ for_each - Iteration");
    println!("   14. ✅ fold - Custom aggregation");
    println!("   15. ✅ all_match - Validation (short-circuit)");
    println!("   16. ✅ into_iter - For loop support");
    println!("   17. ✅ map_items - Transformation\n");

    println!("✅ Arc<RwLock<T>> Benefits:");
    println!("   • Thread-safe shared access");
    println!("   • Interior mutability");
    println!("   • Multiple readers, single writer");
    println!("   • Reference counting (Arc)");
    println!("   • Can be queried after extracting data\n");

    println!("✅ HashMap<K, Arc<RwLock<V>>> Benefits:");
    println!("   • Fast key-based lookup");
    println!("   • Thread-safe value access");
    println!("   • Can query all values");
    println!("   • Can filter by key patterns");
    println!("   • Perfect for shared state/caches\n");

    println!("🎯 Use Cases:");
    println!("   • Shared product catalogs");
    println!("   • User session stores");
    println!("   • Configuration caches");
    println!("   • Real-time inventory systems");
    println!("   • Multi-threaded data processing");
    println!("   • Web server state management\n");

    println!("✓ Arc<RwLock<T>> HashMap with all lazy operations demo complete!\n");
}

pub fn skip_lazy( self, n: usize, ) -> LazyQuery<'a, T, impl Iterator<Item = &'a T> + 'a>

where I: 'a,

Skips n items (lazy).

Example

let page_2: Vec<_> = LazyQuery::new(&products)
    .skip_lazy(10)
    .take_lazy(10)
    .collect();

Examples found in repository

examples/arc_rwlock_hashmap.rs (line 143)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Arc<RwLock<T>> HashMap Lazy Query Demo                         ║");
    println!("║  Thread-safe shared data with lazy evaluation                   ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    let product_map = create_sample_data();
    println!("Created product catalog:");
    println!("  Total products: {}", product_map.len());
    println!("  Keys: {:?}\n", product_map.keys().take(3).collect::<Vec<_>>());

    // Extract products for querying
    let products = extract_products(&product_map);
    println!("Extracted {} products from Arc<RwLock<Product>>\n", products.len());

    // ============================================================================
    // LAZY OPERATION 1: where_ - Lazy Filtering
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 1: where_ (filtering)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building filtered query (nothing executes yet)...");
    let electronics_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::active_r(), |&active| active)
        .where_(Product::stock_r(), |&stock| stock > 20);

    println!("  ✅ Query built (deferred execution)\n");

    println!("Collecting results (executes now)...");
    let electronics: Vec<_> = electronics_query.collect();
    println!("  Found {} electronics in stock", electronics.len());
    for p in &electronics {
        println!("    • {}: {} in stock", p.name, p.stock);
    }

    // ============================================================================
    // LAZY OPERATION 2: select_lazy - Lazy Projection
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 2: select_lazy (projection)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting product names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .select_lazy(Product::name_r())
        .collect();

    println!("  Furniture names ({}):", names.len());
    for name in &names {
        println!("    • {}", name);
    }

    // ============================================================================
    // LAZY OPERATION 3: take_lazy - Early Termination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 3: take_lazy (early termination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting first 3 electronics...");
    let first_3: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
        .collect();

    println!("  First 3 electronics:");
    for (i, p) in first_3.iter().enumerate() {
        println!("    {}. {} - ${:.2}", i + 1, p.name, p.price);
    }
    println!("  ✅ Stopped after finding 3 items!");

    // ============================================================================
    // LAZY OPERATION 4: skip_lazy - Pagination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 4: skip_lazy (pagination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting page 2 (skip 3, take 3)...");
    let page_2: Vec<_> = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .skip_lazy(3)
        .take_lazy(3)
        .collect();

    println!("  Page 2 items:");
    for (i, p) in page_2.iter().enumerate() {
        println!("    {}. {}", i + 4, p.name);
    }

    // ============================================================================
    // LAZY OPERATION 5: first - Short-Circuit Search
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 5: first (short-circuit)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Finding first expensive item (>$1000)...");
    let expensive = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0)
        .first();

    match expensive {
        Some(p) => println!("  Found: {} - ${:.2}", p.name, p.price),
        None => println!("  Not found"),
    }
    println!("  ✅ Stopped at first match!");

    // ============================================================================
    // LAZY OPERATION 6: any - Existence Check
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 6: any (existence check)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Checking if any furniture exists...");
    let has_furniture = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .any();

    println!("  Has furniture: {}", has_furniture);
    println!("  ✅ Stopped immediately after finding first match!");

    // ============================================================================
    // LAZY OPERATION 7: count - Count Matching Items
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 7: count");
    println!("═══════════════════════════════════════════════════════════════\n");

    let electronics_count = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .count();

    println!("  Electronics count: {}", electronics_count);

    // ============================================================================
    // LAZY OPERATION 8: sum_by - Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 8: sum_by (aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_value: f64 = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .sum_by(Product::price_r());

    println!("  Total electronics value: ${:.2}", total_value);

    // ============================================================================
    // LAZY OPERATION 9: avg_by - Average
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 9: avg_by");
    println!("═══════════════════════════════════════════════════════════════\n");

    let avg_price = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .avg_by(Product::price_r())
        .unwrap_or(0.0);

    println!("  Average furniture price: ${:.2}", avg_price);

    // ============================================================================
    // LAZY OPERATION 10: min_by_float / max_by_float
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 10: min_by_float / max_by_float");
    println!("═══════════════════════════════════════════════════════════════\n");

    let min_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .min_by_float(Product::price_r())
        .unwrap_or(0.0);

    let max_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .max_by_float(Product::price_r())
        .unwrap_or(0.0);

    println!("  Price range for active products:");
    println!("    Min: ${:.2}", min_price);
    println!("    Max: ${:.2}", max_price);

    // ============================================================================
    // LAZY OPERATION 11: find - Find with Predicate
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 11: find (with predicate)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let high_rated = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .find(|item| item.rating > 4.7);

    if let Some(product) = high_rated {
        println!("  First highly-rated electronic:");
        println!("    {}: Rating {:.1}", product.name, product.rating);
    }

    // ============================================================================
    // LAZY OPERATION 12: for_each - Iteration
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 12: for_each (iteration)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  Low stock alerts:");
    LazyQuery::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .for_each(|product| {
            println!("    ⚠️  {}: Only {} in stock", product.name, product.stock);
        });

    // ============================================================================
    // LAZY OPERATION 13: fold - Custom Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 14: fold (custom aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_inventory_value = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .fold(0.0, |acc, product| {
            acc + (product.price * product.stock as f64)
        });

    println!("  Total inventory value: ${:.2}", total_inventory_value);

    // ============================================================================
    // LAZY OPERATION 14: all_match - Validation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 15: all_match (validation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let all_priced = LazyQuery::new(&products)
        .all_match(|item| item.price > 0.0);

    println!("  All products have valid prices: {}", all_priced);

    // ============================================================================
    // LAZY OPERATION 15: into_iter - For Loop
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 16: into_iter (for loop)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  High-value products (>$300):");
    for product in LazyQuery::new(&products)
        .where_(Product::price_r(), |&p| p > 300.0)
        .take_lazy(5)
    {
        println!("    • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // LAZY OPERATION 16: map_items - Transform
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 17: map_items (transformation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let price_tags: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .map_items(|p| format!("{}: ${:.2}", p.name, p.price))
        .take(5)
        .collect();

    println!("  Electronics price tags:");
    for tag in &price_tags {
        println!("    • {}", tag);
    }

    // ============================================================================
    // COMPLEX EXAMPLE: Multi-Stage Lazy Pipeline
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Multi-stage lazy pipeline");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building complex query:");
    println!("  1. Filter by category (Electronics)");
    println!("  2. Filter by price range ($50-$500)");
    println!("  3. Filter by rating (>4.5)");
    println!("  4. Select names");
    println!("  5. Take first 3");
    println!();

    let results: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p >= 50.0 && p <= 500.0)
        .where_(Product::rating_r(), |&r| r > 4.5)
        .select_lazy(Product::name_r())
        .take(3)
        .collect();

    println!("  Results:");
    for (i, name) in results.iter().enumerate() {
        println!("    {}. {}", i + 1, name);
    }
    println!("  ✅ All operations fused and executed lazily!");

    // ============================================================================
    // THREAD-SAFE UPDATES WITH RWLOCK
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Bonus: Thread-safe updates with RwLock");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Update a product through the Arc<RwLock>
    if let Some(product_arc) = product_map.get("PROD-002") {
        println!("Updating PROD-002 stock...");
        
        // Write lock for mutation
        if let Ok(mut product) = product_arc.write() {
            let old_stock = product.stock;
            product.stock = 25;
            println!("  Stock updated: {} → {}", old_stock, product.stock);
        }
    }

    // Query again to see the update
    let updated_products = extract_products(&product_map);
    let mouse = LazyQuery::new(&updated_products)
        .find(|p| p.id == 2);

    if let Some(product) = mouse {
        println!("  Verified update: {} now has {} in stock", product.name, product.stock);
    }

    // ============================================================================
    // PRACTICAL EXAMPLE: Price Analysis by Category
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Practical Example: Price analysis by category");
    println!("═══════════════════════════════════════════════════════════════\n");

    let categories = vec!["Electronics", "Furniture"];

    for category in categories {
        println!("  {} Statistics:", category);
        
        // Filter products by category first
        let cat_products: Vec<Product> = products.iter()
            .filter(|p| p.category == category)
            .cloned()
            .collect();

        let count = LazyQuery::new(&cat_products).count();
        let total = LazyQuery::new(&cat_products).sum_by(Product::price_r());
        let avg = LazyQuery::new(&cat_products).avg_by(Product::price_r()).unwrap_or(0.0);
        let min = LazyQuery::new(&cat_products).min_by_float(Product::price_r()).unwrap_or(0.0);
        let max = LazyQuery::new(&cat_products).max_by_float(Product::price_r()).unwrap_or(0.0);

        println!("    Count: {}", count);
        println!("    Total: ${:.2}", total);
        println!("    Average: ${:.2}", avg);
        println!("    Range: ${:.2} - ${:.2}\n", min, max);
    }

    // ============================================================================
    // COMBINING WITH HASHMAP OPERATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("HashMap Integration: Query by key patterns");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Filter HashMap by key pattern
    let electronics_keys: Vec<String> = product_map
        .iter()
        .filter(|(_key, value)| {
            // Read the value to check category
            if let Ok(guard) = value.read() {
                guard.category == "Electronics"
            } else {
                false
            }
        })
        .map(|(key, _value)| key.clone())
        .collect();

    println!("  Electronics product IDs:");
    for key in electronics_keys.iter().take(5) {
        println!("    • {}", key);
    }

    // ============================================================================
    // PERFORMANCE DEMONSTRATION
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Performance: Lazy vs Eager comparison");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first product with rating > 4.7 from {} products\n", products.len());

    println!("  Eager approach (hypothetical):");
    println!("    - Filter all {} products", products.len());
    println!("    - Collect filtered results");
    println!("    - Take first item");
    println!("    - Wasted work: Check all items\n");

    println!("  Lazy approach (actual):");
    let _first_rated = LazyQuery::new(&products)
        .where_(Product::rating_r(), |&r| r > 4.7)
        .first();
    println!("    - Starts checking products");
    println!("    - Stops at first match");
    println!("    - ✅ Early termination - checks ~3-5 items only!");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: All Lazy Operations Demonstrated                      ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Lazy Query Operations:");
    println!("   1. ✅ where_ - Lazy filtering");
    println!("   2. ✅ select_lazy - Lazy projection");
    println!("   3. ✅ take_lazy - Early termination");
    println!("   4. ✅ skip_lazy - Pagination");
    println!("   5. ✅ first - Short-circuit search");
    println!("   6. ✅ any - Existence check (short-circuit)");
    println!("   7. ✅ count - Count items");
    println!("   8. ✅ sum_by - Sum aggregation");
    println!("   9. ✅ avg_by - Average aggregation");
    println!("   10. ✅ min_by_float - Minimum value");
    println!("   11. ✅ max_by_float - Maximum value");
    println!("   12. ✅ find - Find with predicate (short-circuit)");
    println!("   13. ✅ for_each - Iteration");
    println!("   14. ✅ fold - Custom aggregation");
    println!("   15. ✅ all_match - Validation (short-circuit)");
    println!("   16. ✅ into_iter - For loop support");
    println!("   17. ✅ map_items - Transformation\n");

    println!("✅ Arc<RwLock<T>> Benefits:");
    println!("   • Thread-safe shared access");
    println!("   • Interior mutability");
    println!("   • Multiple readers, single writer");
    println!("   • Reference counting (Arc)");
    println!("   • Can be queried after extracting data\n");

    println!("✅ HashMap<K, Arc<RwLock<V>>> Benefits:");
    println!("   • Fast key-based lookup");
    println!("   • Thread-safe value access");
    println!("   • Can query all values");
    println!("   • Can filter by key patterns");
    println!("   • Perfect for shared state/caches\n");

    println!("🎯 Use Cases:");
    println!("   • Shared product catalogs");
    println!("   • User session stores");
    println!("   • Configuration caches");
    println!("   • Real-time inventory systems");
    println!("   • Multi-threaded data processing");
    println!("   • Web server state management\n");

    println!("✓ Arc<RwLock<T>> HashMap with all lazy operations demo complete!\n");
}

pub fn collect(self) -> Vec<&'a T>

Collects all items into a vector (terminal operation - executes query).

Example

let results: Vec<&Product> = query.collect();

Examples found in repository

examples/individual_crates.rs (line 103)

fn main() {
    println!("Individual Crates Example");
    println!("=========================\n");
    println!("Using rust-queries-core + rust-queries-derive directly\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. QueryExt from rust_queries_core");
    println!("   products.query().where_(price > 100).all()");
    
    let query = products
        .query()  // From QueryExt trait
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. QueryBuilder from rust_queries_derive");
    println!("   Product::query(&products).where_(stock < 10).all()");
    
    let query2 = Product::query(&products)  // From QueryBuilder derive
        .where_(Product::stock_r(), |&s| s < 10);
    let low_stock = query2.all();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. LazyQuery from rust_queries_core");
    println!("   products.lazy_query().where_(...).collect()");
    
    let electronics: Vec<_> = products
        .lazy_query()  // From QueryExt trait
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .collect();
    
    println!("   Found {} electronics:", electronics.len());
    for product in electronics {
        println!("   - {}", product.name);
    }
    println!();

    println!("4. Aggregations with LazyQuery");
    println!("   products.lazy_query().sum_by(Product::price_r())");
    
    let total_value: f64 = products
        .lazy_query()
        .sum_by(Product::price_r());
    
    println!("   Total inventory value: ${:.2}", total_value);
    println!();

    println!("5. Early termination with lazy queries");
    println!("   products.lazy_query().where_(...).first()");
    
    if let Some(first_cheap) = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p < 50.0)
        .first()
    {
        println!("   First cheap product: {} (${:.2})", first_cheap.name, first_cheap.price);
    }
    println!();

    println!("6. Using Query (eager) from rust_queries_core");
    println!("   Query::new(&products).where_(...).count()");
    
    let query3 = Query::new(&products)  // Traditional approach
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query3.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ rust_queries_core provides: Query, LazyQuery, QueryExt");
    println!("✓ rust_queries_derive provides: #[derive(QueryBuilder)]");
    println!("✓ key_paths_derive provides: #[derive(Keypaths)]");
    println!("✓ All features work with individual crates!");
}

examples/derive_and_ext.rs (line 75)

fn main() {
    println!("Derive Macros and Extension Traits Example");
    println!("===========================================\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. Using Extension Trait - Direct .query() on Vec");
    println!("   Query: products.query().where_(price > 100).all()");
    
    let query = products
        .query()
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in &expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. Using Extension Trait - Direct .lazy_query() on Vec");
    println!("   Query: products.lazy_query().where_(stock < 10).collect()");
    
    let low_stock: Vec<_> = products
        .lazy_query()
        .where_(Product::stock_r(), |&s| s < 10)
        .collect();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in &low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. Using Extension Trait - Chained Operations");
    println!("   Query: products.lazy_query().where_(category == Electronics).take(2).select(name).collect()");
    
    let names: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(2)
        .select_lazy(Product::name_r())
        .collect();
    
    println!("   First 2 electronics:");
    for name in &names {
        println!("   - {}", name);
    }
    println!();

    println!("4. Using QueryBuilder Derive - Static Methods");
    println!("   Query: Product::query(&products).where_(price > 50).count()");
    
    let query4 = Product::query(&products)
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query4.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("5. Using QueryBuilder Derive - Lazy Static Methods");
    println!("   Query: Product::lazy_query(&products).first()");
    
    if let Some(first) = Product::lazy_query(&products).first() {
        println!("   First product: {} (${:.2})", first.name, first.price);
    }
    println!();

    println!("6. Complex Chain with Extension Trait");
    println!("   Query: products.lazy_query()");
    println!("          .where_(category == Electronics)");
    println!("          .where_(price < 500)");
    println!("          .map(|p| format!(\"{{}} - ${{:.2}}\", p.name, p.price))");
    println!("          .collect()");
    
    let formatted: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .map_items(|p| format!("{} - ${:.2}", p.name, p.price))
        .collect();
    
    println!("   Affordable electronics:");
    for item in &formatted {
        println!("   - {}", item);
    }
    println!();

    println!("7. Aggregation with Extension Trait");
    println!("   Query: products.lazy_query().sum_by(Product::stock())");
    
    let total_stock = products
        .lazy_query()
        .sum_by(Product::stock_r());
    
    println!("   Total stock across all products: {}", total_stock);
    println!();

    println!("8. Find with Extension Trait");
    println!("   Query: products.lazy_query().find(|p| p.name.contains(\"Chair\"))");
    
    if let Some(chair) = products.lazy_query().find(|p| p.name.contains("Chair")) {
        println!("   Found: {} in {}", chair.name, chair.category);
    }
    println!();

    println!("9. Early Termination with Extension Trait");
    println!("   Query: products.lazy_query().where_(price > 1000).any()");
    
    let has_luxury = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p > 1000.0)
        .any();
    
    println!("   Has products over $1000: {}", has_luxury);
    println!();

    println!("10. Slice Extension Trait");
    println!("    Query: (&products[..]).lazy_query().count()");
    
    let slice_count = (&products[..])
        .lazy_query()
        .count();
    
    println!("    Count from slice: {}", slice_count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ Extension trait QueryExt adds .query() and .lazy_query() to containers");
    println!("✓ Derive macro QueryBuilder adds static methods Product::query() and Product::lazy_query()");
    println!("✓ Both approaches provide the same query functionality");
    println!("✓ Extension trait is more ergonomic: products.query() vs Query::new(&products)");
    println!("✓ All iterator optimizations (fusion, early termination) still apply");
}

examples/container_support.rs (line 103)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Container Support Demo                                       ║");
    println!("║  Query various collection types                               ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // ============================================================================
    // CONTAINER 1: Vec<T>
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Container 1: Vec<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let vec_products = vec![
        create_sample_product(1, "Laptop", 999, "Electronics"),
        create_sample_product(2, "Mouse", 29, "Electronics"),
        create_sample_product(3, "Desk", 299, "Furniture"),
    ];

    // Query Vec directly
    let vec_query = Query::new(&vec_products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let vec_results = vec_query.all();
    println!("  Vec: Found {} electronics", vec_results.len());

    // Lazy query on Vec
    let lazy_count = LazyQuery::new(&vec_products)
        .where_(Product::price_r(), |&p| p < 100)
        .count();
    println!("  Vec (lazy): {} items under $100", lazy_count);

    // ============================================================================
    // CONTAINER 2: VecDeque<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 2: VecDeque<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut deque_products = VecDeque::new();
    deque_products.push_back(create_sample_product(1, "Keyboard", 129, "Electronics"));
    deque_products.push_back(create_sample_product(2, "Monitor", 349, "Electronics"));
    deque_products.push_back(create_sample_product(3, "Chair", 199, "Furniture"));

    // Convert to owned Vec for querying
    let deque_vec: Vec<Product> = deque_products.iter().cloned().collect();
    let deque_query = Query::new(&deque_vec);
    let deque_count = deque_query.count();
    println!("  VecDeque: {} total items", deque_count);

    // More efficient: use make_contiguous for zero-copy slice access
    let contiguous = deque_products.make_contiguous();
    let contiguous_query = Query::new(contiguous);
    println!("  VecDeque (zero-copy): {} items", contiguous_query.count());

    // ============================================================================
    // CONTAINER 3: HashSet<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 3: HashSet<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut set_products = HashSet::new();
    set_products.insert(create_sample_product(1, "Tablet", 499, "Electronics"));
    set_products.insert(create_sample_product(2, "Phone", 799, "Electronics"));
    set_products.insert(create_sample_product(3, "Lamp", 39, "Furniture"));

    // Collect from HashSet to Vec for querying
    let set_vec: Vec<Product> = set_products.iter().cloned().collect();
    let set_query = Query::new(&set_vec)
        .where_(Product::price_r(), |&p| p > 500);
    let expensive = set_query.all();
    println!("  HashSet: {} expensive items", expensive.len());

    // Lazy on HashSet (convert to owned Vec first)
    let set_owned: Vec<Product> = set_products.iter().cloned().collect();
    let lazy_set: Vec<_> = LazyQuery::new(&set_owned)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .collect();
    println!("  HashSet (lazy): {} electronics", lazy_set.len());

    // ============================================================================
    // CONTAINER 4: BTreeSet<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 4: BTreeSet<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut btree_set = BTreeSet::new();
    btree_set.insert(create_sample_product(1, "Webcam", 79, "Electronics"));
    btree_set.insert(create_sample_product(2, "Microphone", 129, "Electronics"));
    btree_set.insert(create_sample_product(3, "Bookshelf", 149, "Furniture"));

    let btree_vec: Vec<Product> = btree_set.iter().cloned().collect();
    let btree_query = Query::new(&btree_vec);
    println!("  BTreeSet: {} total items (sorted order!)", btree_query.count());
    
    // BTreeSet items are in sorted order
    for (i, item) in btree_vec.iter().take(3).enumerate() {
        println!("    {}. {} (ID: {})", i + 1, item.name, item.id);
    }

    // ============================================================================
    // CONTAINER 5: HashMap<K, V> - Query Values
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 5: HashMap<K, V> - Querying values");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut map_products = HashMap::new();
    map_products.insert("prod1", create_sample_product(1, "Speaker", 199, "Electronics"));
    map_products.insert("prod2", create_sample_product(2, "Headphones", 149, "Electronics"));
    map_products.insert("prod3", create_sample_product(3, "Ottoman", 249, "Furniture"));

    // Query HashMap values (convert to owned Vec)
    let map_vec: Vec<Product> = map_products.values().cloned().collect();
    let map_query = Query::new(&map_vec)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = map_query.all();
    println!("  HashMap: {} electronics", electronics.len());

    // ============================================================================
    // CONTAINER 6: BTreeMap<K, V> - Query Values
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 6: BTreeMap<K, V> - Querying values");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut btree_map = BTreeMap::new();
    btree_map.insert(1, create_sample_product(1, "Router", 89, "Electronics"));
    btree_map.insert(2, create_sample_product(2, "Switch", 129, "Electronics"));
    btree_map.insert(3, create_sample_product(3, "Sofa", 899, "Furniture"));

    let btree_map_vec: Vec<Product> = btree_map.values().cloned().collect();
    let btree_map_query = Query::new(&btree_map_vec);
    let avg_price = btree_map_query.sum(Product::price_r()) as f64 / btree_map.len() as f64;
    println!("  BTreeMap: Average price ${:.2}", avg_price);

    // ============================================================================
    // CONTAINER 7: Arrays [T; N]
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 7: Arrays [T; N]");
    println!("═══════════════════════════════════════════════════════════════\n");

    let array_products = [
        create_sample_product(1, "USB Cable", 15, "Electronics"),
        create_sample_product(2, "HDMI Cable", 25, "Electronics"),
        create_sample_product(3, "Power Strip", 35, "Electronics"),
    ];

    // Query array directly (as slice)
    let array_query = Query::new(&array_products);
    let total = array_query.sum(Product::price_r());
    println!("  Array: Total value ${}", total);

    // Lazy on array
    let lazy_array: Vec<_> = LazyQuery::new(&array_products)
        .where_(Product::price_r(), |&p| p > 20)
        .collect();
    println!("  Array (lazy): {} items over $20", lazy_array.len());

    // ============================================================================
    // CONTAINER 8: LinkedList<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 8: LinkedList<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut list_products = LinkedList::new();
    list_products.push_back(create_sample_product(1, "SSD", 159, "Electronics"));
    list_products.push_back(create_sample_product(2, "HDD", 79, "Electronics"));

    let list_vec: Vec<Product> = list_products.iter().cloned().collect();
    let list_query = Query::new(&list_vec);
    println!("  LinkedList: {} items", list_query.count());

    // ============================================================================
    // CONTAINER 9: Option<T> and Result<T, E>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 9: Option<T> and Result<T, E>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let maybe_product = Some(create_sample_product(1, "Mystery Box", 99, "Special"));
    
    if let Some(ref product) = maybe_product {
        let option_query = Query::new(std::slice::from_ref(product));
        println!("  Option (Some): {} items", option_query.count());
    }

    let none_product: Option<Product> = None;
    let none_count = none_product.iter().count();
    println!("  Option (None): {} items", none_count);

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Supported Containers Summary                                  ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Supported container types:");
    println!("   • Vec<T>              - Standard vector");
    println!("   • &[T]                - Slices");
    println!("   • [T; N]              - Fixed-size arrays");
    println!("   • VecDeque<T>         - Double-ended queue");
    println!("   • LinkedList<T>       - Doubly-linked list");
    println!("   • HashSet<T>          - Unordered set");
    println!("   • BTreeSet<T>         - Ordered set");
    println!("   • HashMap<K, V>       - Query values");
    println!("   • BTreeMap<K, V>      - Query values (sorted)");
    println!("   • Option<T>           - 0 or 1 item");
    println!("   • Result<T, E>        - 0 or 1 item\n");

    println!("📝 Usage patterns:");
    println!("   • Direct: Query::new(&container) for Vec, slices, arrays");
    println!("   • Convert: Collect to Vec for Sets and Maps");
    println!("   • Lazy: LazyQuery::new(&slice) for any slice\n");

    println!("💡 Tips:");
    println!("   • Vec/slice: Direct support, most efficient");
    println!("   • Sets: Iterate to Vec, then query");
    println!("   • Maps: Use .values().collect() to query values");
    println!("   • VecDeque: Use .as_slices() for zero-copy");
    println!("   • For custom types: Implement Queryable trait\n");

    println!("✓ Container support demo complete!\n");
}

examples/lazy_evaluation.rs (line 79)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Lazy Query Evaluation Demo                                   ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    let products = create_products();
    println!("Created {} products\n", products.len());

    // ============================================================================
    // DEMO 1: Lazy Execution - Nothing Happens Until .collect()
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 1: Lazy execution - deferred until needed");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Building query (should execute nothing)...");
    let lazy_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            cat == "Electronics"
        });

    let evals_after_build = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Filter evaluations after building query: {}", evals_after_build);
    
    if evals_after_build == 0 {
        println!("  ✅ Confirmed: Query is lazy! Nothing executed yet.\n");
    }

    println!("Collecting results (now it executes)...");
    let results: Vec<_> = lazy_query.collect();

    let evals_after_collect = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Filter evaluations after collecting: {}", evals_after_collect);
    println!("  Results found: {}", results.len());
    println!("  ✅ Query executed exactly once, when needed!\n");

    // ============================================================================
    // DEMO 2: Early Termination - Stops as Soon as Enough Items Found
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 2: Early termination with .take()");
    println!("═══════════════════════════════════════════════════════════════\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);

    println!("Finding first 5 expensive items from 1000 products...");
    let first_5: Vec<_> = LazyQuery::new(&products)
        .where_(Product::price_r(), |p| expensive_check(p))
        .take_lazy(5)
        .collect();

    let ops = EXPENSIVE_OPERATIONS.load(Ordering::SeqCst);
    println!("  Found: {} items", first_5.len());
    println!("  Expensive operations performed: {}", ops);
    println!("  Items NOT checked: {} (stopped early!)", 1000 - ops);
    
    if ops < 1000 {
        println!("  ✅ Early termination worked! Didn't check all 1000 items.\n");
    }

    // ============================================================================
    // DEMO 3: Iterator Fusion - Rust Optimizes Chained Operations
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 3: Iterator fusion - chained operations optimized");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Chaining multiple operations...");
    let chained_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price > 200.0)
        .where_(Product::stock_r(), |&stock| stock > 10)
        .take_lazy(10);

    println!("  Built query with 3 filters + take(10)");
    println!("  ✅ No execution yet - all operations fused into one iterator\n");

    let results: Vec<_> = chained_query.collect();
    println!("  Executed: Found {} items", results.len());
    println!("  ✅ All filters applied in single pass!\n");

    // ============================================================================
    // DEMO 4: Lazy Projection - Only Extract What You Need
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 4: Lazy projection");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .select_lazy(Product::name_r())
        .take(5)  // Only process until we have 5
        .collect();

    println!("  Selected {} names", names.len());
    println!("  ✅ Only evaluated until 5 names found!\n");

    // ============================================================================
    // DEMO 5: Lazy Aggregation - Short-Circuit When Possible
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 5: Short-circuit with .any()");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Checking if ANY electronics exist (1000 items to search)...");
    let exists = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            cat == "Electronics"
        })
        .any();

    let checks = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Result: {}", exists);
    println!("  Items checked: {} out of 1000", checks);
    println!("  Items skipped: {} (short-circuited!)", 1000 - checks);
    
    if checks < 1000 {
        println!("  ✅ Short-circuit worked! Stopped as soon as first match found.\n");
    }

    // ============================================================================
    // DEMO 6: Lazy Find - Stops at First Match
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 6: .find() stops at first match");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Finding first product with price > 500...");
    let found = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            price > 500.0
        })
        .first();

    let checks = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    if let Some(product) = found {
        println!("  Found: {} (${:.2})", product.name, product.price);
    }
    println!("  Items checked: {} out of 1000", checks);
    println!("  ✅ Stopped immediately after finding first match!\n");

    // ============================================================================
    // DEMO 7: Composition - Build Queries Incrementally
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 7: Composable queries");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building base query...");
    let base_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Created base query (not executed)\n");

    println!("  Adding price filter...");
    let refined_query = base_query
        .where_(Product::price_r(), |&price| price > 100.0);

    println!("  Still not executed...\n");

    println!("  Adding stock filter and limiting...");
    let final_query = refined_query
        .where_(Product::stock_r(), |&stock| stock > 5)
        .take_lazy(10);

    println!("  Still not executed...\n");

    println!("  Executing...");
    let results: Vec<_> = final_query.collect();
    println!("  ✅ Executed once with all filters: Found {} items\n", results.len());

    // ============================================================================
    // DEMO 8: For Loop - Natural Iteration
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 8: Use in for loops");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Iterating over filtered products...");
    let mut count = 0;
    for product in LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
    {
        println!("  • {}: ${:.2}", product.name, product.price);
        count += 1;
    }
    println!("  ✅ Processed {} items lazily\n", count);

    // ============================================================================
    // DEMO 9: Performance Comparison
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 9: Performance benefit demonstration");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first expensive item from 1000 products\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);
    
    println!("Without lazy (hypothetical - check all, then take first):");
    println!("  Would check: 1000 items");
    println!("  Would find: ~300 matching items");
    println!("  Would return: 1 item");
    println!("  Wasted work: 299 items processed unnecessarily\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);
    
    println!("With lazy evaluation:");
    let _first = LazyQuery::new(&products)
        .where_(Product::price_r(), |p| expensive_check(p))
        .first();

    let ops = EXPENSIVE_OPERATIONS.load(Ordering::SeqCst);
    println!("  Checked: {} items", ops);
    println!("  Found: 1 item");
    println!("  Wasted work: 0 items");
    println!("  ✅ Efficiency gain: {}x faster!", 1000 / ops.max(1));

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Lazy Evaluation Benefits                                     ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Deferred Execution:");
    println!("   • No work until results needed");
    println!("   • Can build complex queries without performance cost\n");

    println!("✅ Early Termination:");
    println!("   • .take(n) stops after n items");
    println!("   • .first() stops after 1 item");
    println!("   • .any() stops after first match");
    println!("   • Massive performance win for large datasets\n");

    println!("✅ Iterator Fusion:");
    println!("   • Multiple filters combined into one pass");
    println!("   • Rust compiler optimizes chained operations");
    println!("   • No intermediate allocations\n");

    println!("✅ Composable:");
    println!("   • Build queries incrementally");
    println!("   • Reuse query fragments");
    println!("   • Clean separation of query building vs execution\n");

    println!("✅ Zero Overhead:");
    println!("   • Compiles to same code as manual loops");
    println!("   • No runtime cost for abstraction");
    println!("   • Pay only for what you use\n");

    println!("✓ Lazy evaluation demo complete!\n");
}

examples/macro_helpers.rs (line 330)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Macro Helpers Demo - Reducing Boilerplate                    ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    let products = create_products();

    // ============================================================================
    // EXAMPLE 1: Simple Collection
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 1: collect_lazy! - Simple collection");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let results: Vec<_> = LazyQuery::new(&products).collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let results = collect_lazy!(&products);");
    println!("```\n");

    let results = collect_lazy!(&products);
    println!("Result: {} products collected\n", results.len());

    // ============================================================================
    // EXAMPLE 2: Filter and Collect
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 2: filter_collect! - Filter and collect");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let electronics: Vec<_> = LazyQuery::new(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Electronics\")");
    println!("    .collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let electronics = filter_collect!(");
    println!("    &products,");
    println!("    Product::category_r(),");
    println!("    |cat| cat == \"Electronics\"");
    println!(");");
    println!("```\n");

    let electronics = filter_collect!(
        &products,
        Product::category_r(),
        |cat| cat == "Electronics"
    );
    println!("Result: {} electronics\n", electronics.len());

    // ============================================================================
    // EXAMPLE 3: Count with Filter
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 3: count_where! - Count with filter");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let count = LazyQuery::new(&products)");
    println!("    .where_(Product::stock_r(), |&s| s > 0)");
    println!("    .count();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let count = count_where!(&products, Product::stock_r(), |&s| s > 0);");
    println!("```\n");

    let count = count_where!(&products, Product::stock_r(), |&s| s > 0);
    println!("Result: {} products in stock\n", count);

    // ============================================================================
    // EXAMPLE 4: Find First
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 4: find_first! - Find first matching item");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let found = LazyQuery::new(&products)");
    println!("    .where_(Product::price_r(), |&p| p > 500.0)");
    println!("    .first();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let found = find_first!(&products, Product::price_r(), |&p| p > 500.0);");
    println!("```\n");

    let found = find_first!(&products, Product::price_r(), |&p| p > 500.0);
    if let Some(p) = found {
        println!("Result: Found {} at ${:.2}\n", p.name, p.price);
    }

    // ============================================================================
    // EXAMPLE 5: Existence Check
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 5: exists_where! - Check if any item matches");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let has_furniture = LazyQuery::new(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Furniture\")");
    println!("    .any();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let has_furniture = exists_where!(");
    println!("    &products,");
    println!("    Product::category_r(),");
    println!("    |cat| cat == \"Furniture\"");
    println!(");");
    println!("```\n");

    let has_furniture = exists_where!(
        &products,
        Product::category_r(),
        |cat| cat == "Furniture"
    );
    println!("Result: Has furniture = {}\n", has_furniture);

    // ============================================================================
    // EXAMPLE 6: Pagination
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 6: paginate! - Quick pagination");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let page_2: Vec<_> = LazyQuery::new(&products)");
    println!("    .skip_lazy(1 * 2)  // page * size");
    println!("    .take_lazy(2)");
    println!("    .collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let page_2 = paginate!(&products, page: 1, size: 2);");
    println!("```\n");

    let page_2 = paginate!(&products, page: 1, size: 2);
    println!("Result: Page 2 has {} items\n", page_2.len());

    // ============================================================================
    // EXAMPLE 7: Sum with Filter
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 7: sum_where! - Sum with filter");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let total: f64 = LazyQuery::new(&products)");
    println!("    .where_(Product::active_r(), |&a| a)");
    println!("    .sum_by(Product::price_r());");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let total = sum_where!(&products, Product::price_r(), Product::active_r(), |&a| a);");
    println!("```\n");

    let total = sum_where!(&products, Product::price_r(), Product::active_r(), |&a| a);
    println!("Result: Total active products value = ${:.2}\n", total);

    // ============================================================================
    // EXAMPLE 8: Average with Filter
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 8: avg_where! - Average with filter");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let avg = LazyQuery::new(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Electronics\")");
    println!("    .avg_by(Product::price_r())");
    println!("    .unwrap_or(0.0);");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let avg = avg_where!(");
    println!("    &products,");
    println!("    Product::price_r(),");
    println!("    Product::category_r(),");
    println!("    |cat| cat == \"Electronics\"");
    println!(").unwrap_or(0.0);");
    println!("```\n");

    let avg = avg_where!(
        &products,
        Product::price_r(),
        Product::category_r(),
        |cat| cat == "Electronics"
    ).unwrap_or(0.0);
    println!("Result: Average electronics price = ${:.2}\n", avg);

    // ============================================================================
    // EXAMPLE 9: Select All
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 9: select_all! - Select field from all items");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let names: Vec<String> = LazyQuery::new(&products)");
    println!("    .select_lazy(Product::name_r())");
    println!("    .collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let names = select_all!(&products, Product::name_r());");
    println!("```\n");

    let names: Vec<String> = select_all!(&products, Product::name_r());
    println!("Result: {} product names\n", names.len());

    // ============================================================================
    // EXAMPLE 10: Select with Filter
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Example 10: select_where! - Select field with filter");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❌ Without macro (verbose):");
    println!("```rust");
    println!("let furniture_names: Vec<String> = LazyQuery::new(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Furniture\")");
    println!("    .select_lazy(Product::name_r())");
    println!("    .collect();");
    println!("```\n");

    println!("✅ With macro (concise):");
    println!("```rust");
    println!("let furniture_names = select_where!(");
    println!("    &products,");
    println!("    Product::name_r(),");
    println!("    Product::category_r(),");
    println!("    |cat| cat == \"Furniture\"");
    println!(");");
    println!("```\n");

    let furniture_names: Vec<String> = select_where!(
        &products,
        Product::name_r(),
        Product::category_r(),
        |cat| cat == "Furniture"
    );
    println!("Result: {} furniture items\n", furniture_names.len());

    // ============================================================================
    // COMPARISON: Complex Query
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Before & After");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Filter electronics, under $500, in stock, get first 5\n");

    println!("❌ WITHOUT MACROS (13 lines):");
    println!("```rust");
    println!("let results: Vec<_> = LazyQuery::new(&products)");
    println!("    .where_(");
    println!("        Product::category_r(),");
    println!("        |cat| cat == \"Electronics\"");
    println!("    )");
    println!("    .where_(Product::price_r(), |&p| p < 500.0)");
    println!("    .where_(Product::stock_r(), |&s| s > 0)");
    println!("    .take_lazy(5)");
    println!("    .collect();");
    println!("```\n");

    // Actual verbose version
    let verbose_results: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .where_(Product::stock_r(), |&s| s > 0)
        .take_lazy(5)
        .collect();

    println!("✅ WITH MACROS (Shorter, but still need multiple filters):");
    println!("```rust");
    println!("let results = lazy_query!(&products)");
    println!("    .where_(Product::category_r(), |cat| cat == \"Electronics\")");
    println!("    .where_(Product::price_r(), |&p| p < 500.0)");
    println!("    .where_(Product::stock_r(), |&s| s > 0)");
    println!("    .take_lazy(5)");
    println!("    .collect();");
    println!("```\n");

    let macro_results = lazy_query!(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .where_(Product::stock_r(), |&s| s > 0)
        .take_lazy(5)
        .collect();

    println!("Both approaches found {} items ✅\n", verbose_results.len());
    assert_eq!(verbose_results.len(), macro_results.len());

    // ============================================================================
    // CODE REDUCTION METRICS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Code Reduction Metrics");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Pattern Comparisons:\n");

    println!("  1. Simple collect:");
    println!("     Before: LazyQuery::new(&data).collect()");
    println!("     After:  collect_lazy!(&data)");
    println!("     Saved:  ~20 characters\n");

    println!("  2. Filter + collect:");
    println!("     Before: LazyQuery::new(&data).where_(...).collect()");
    println!("     After:  filter_collect!(&data, field, pred)");
    println!("     Saved:  ~35 characters\n");

    println!("  3. Count with filter:");
    println!("     Before: LazyQuery::new(&data).where_(...).count()");
    println!("     After:  count_where!(&data, field, pred)");
    println!("     Saved:  ~30 characters\n");

    println!("  4. Pagination:");
    println!("     Before: LazyQuery::new(&data).skip_lazy(p*s).take_lazy(s).collect()");
    println!("     After:  paginate!(&data, page: p, size: s)");
    println!("     Saved:  ~45 characters\n");

    println!("  5. Sum with filter:");
    println!("     Before: LazyQuery::new(&data).where_(...).sum_by(...)");
    println!("     After:  sum_where!(&data, sum_field, filter_field, pred)");
    println!("     Saved:  ~25 characters\n");

    // ============================================================================
    // ALL MACRO DEMONSTRATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("All Available Macros - Quick Reference");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("1. lazy_query!(&data)");
    let _q1 = lazy_query!(&products);
    println!("   → LazyQuery::new(&data)\n");

    println!("2. query!(&data)");
    let _q2 = query!(&products);
    println!("   → Query::new(&data)\n");

    println!("3. collect_lazy!(&data)");
    let _r3 = collect_lazy!(&products);
    println!("   → LazyQuery::new(&data).collect()\n");

    println!("4. filter_collect!(&data, field, pred)");
    let _r4 = filter_collect!(&products, Product::active_r(), |&a| a);
    println!("   → LazyQuery::new(&data).where_(field, pred).collect()\n");

    println!("5. count_where!(&data, field, pred)");
    let _r5 = count_where!(&products, Product::active_r(), |&a| a);
    println!("   → LazyQuery::new(&data).where_(field, pred).count()\n");

    println!("6. find_first!(&data, field, pred)");
    let _r6 = find_first!(&products, Product::id_r(), |&id| id == 1);
    println!("   → LazyQuery::new(&data).where_(field, pred).first()\n");

    println!("7. exists_where!(&data, field, pred)");
    let _r7 = exists_where!(&products, Product::active_r(), |&a| a);
    println!("   → LazyQuery::new(&data).where_(field, pred).any()\n");

    println!("8. paginate!(&data, page: p, size: s)");
    let _r8 = paginate!(&products, page: 0, size: 3);
    println!("   → LazyQuery::new(&data).skip_lazy(p*s).take_lazy(s).collect()\n");

    println!("9. sum_where!(&data, sum_field, filter_field, pred)");
    let _r9 = sum_where!(&products, Product::price_r(), Product::active_r(), |&a| a);
    println!("   → LazyQuery::new(&data).where_(filter_field, pred).sum_by(sum_field)\n");

    println!("10. avg_where!(&data, avg_field, filter_field, pred)");
    let _r10 = avg_where!(&products, Product::price_r(), Product::active_r(), |&a| a);
    println!("    → LazyQuery::new(&data).where_(filter_field, pred).avg_by(avg_field)\n");

    println!("11. select_all!(&data, field)");
    let _r11: Vec<String> = select_all!(&products, Product::name_r());
    println!("    → LazyQuery::new(&data).select_lazy(field).collect()\n");

    println!("12. select_where!(&data, select_field, filter_field, pred)");
    let _r12: Vec<String> = select_where!(&products, Product::name_r(), Product::active_r(), |&a| a);
    println!("    → LazyQuery::new(&data).where_(filter, pred).select_lazy(field).collect()\n");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("╔════════════════════════════════════════════════════════════════╗");
    println!("║  Summary                                                       ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ 12 helper macros provided:");
    println!("   • lazy_query! - Create LazyQuery");
    println!("   • query! - Create Query");
    println!("   • collect_lazy! - Quick collect");
    println!("   • filter_collect! - Filter and collect");
    println!("   • count_where! - Count with filter");
    println!("   • find_first! - Find first match");
    println!("   • exists_where! - Existence check");
    println!("   • paginate! - Easy pagination");
    println!("   • sum_where! - Sum with filter");
    println!("   • avg_where! - Average with filter");
    println!("   • select_all! - Select all");
    println!("   • select_where! - Select with filter\n");

    println!("📊 Benefits:");
    println!("   • Less typing (20-45 characters saved per operation)");
    println!("   • More readable code");
    println!("   • Common patterns encapsulated");
    println!("   • Same performance (zero-cost abstraction)");
    println!("   • Type-safe (compile-time checked)\n");

    println!("💡 When to use:");
    println!("   • Use macros for simple, common patterns");
    println!("   • Use full API for complex queries");
    println!("   • Mix and match as needed\n");

    println!("✓ Macro helpers demo complete!\n");
}

examples/arc_rwlock_hashmap.rs (line 90)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Arc<RwLock<T>> HashMap Lazy Query Demo                         ║");
    println!("║  Thread-safe shared data with lazy evaluation                   ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    let product_map = create_sample_data();
    println!("Created product catalog:");
    println!("  Total products: {}", product_map.len());
    println!("  Keys: {:?}\n", product_map.keys().take(3).collect::<Vec<_>>());

    // Extract products for querying
    let products = extract_products(&product_map);
    println!("Extracted {} products from Arc<RwLock<Product>>\n", products.len());

    // ============================================================================
    // LAZY OPERATION 1: where_ - Lazy Filtering
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 1: where_ (filtering)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building filtered query (nothing executes yet)...");
    let electronics_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::active_r(), |&active| active)
        .where_(Product::stock_r(), |&stock| stock > 20);

    println!("  ✅ Query built (deferred execution)\n");

    println!("Collecting results (executes now)...");
    let electronics: Vec<_> = electronics_query.collect();
    println!("  Found {} electronics in stock", electronics.len());
    for p in &electronics {
        println!("    • {}: {} in stock", p.name, p.stock);
    }

    // ============================================================================
    // LAZY OPERATION 2: select_lazy - Lazy Projection
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 2: select_lazy (projection)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting product names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .select_lazy(Product::name_r())
        .collect();

    println!("  Furniture names ({}):", names.len());
    for name in &names {
        println!("    • {}", name);
    }

    // ============================================================================
    // LAZY OPERATION 3: take_lazy - Early Termination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 3: take_lazy (early termination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting first 3 electronics...");
    let first_3: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
        .collect();

    println!("  First 3 electronics:");
    for (i, p) in first_3.iter().enumerate() {
        println!("    {}. {} - ${:.2}", i + 1, p.name, p.price);
    }
    println!("  ✅ Stopped after finding 3 items!");

    // ============================================================================
    // LAZY OPERATION 4: skip_lazy - Pagination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 4: skip_lazy (pagination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting page 2 (skip 3, take 3)...");
    let page_2: Vec<_> = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .skip_lazy(3)
        .take_lazy(3)
        .collect();

    println!("  Page 2 items:");
    for (i, p) in page_2.iter().enumerate() {
        println!("    {}. {}", i + 4, p.name);
    }

    // ============================================================================
    // LAZY OPERATION 5: first - Short-Circuit Search
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 5: first (short-circuit)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Finding first expensive item (>$1000)...");
    let expensive = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0)
        .first();

    match expensive {
        Some(p) => println!("  Found: {} - ${:.2}", p.name, p.price),
        None => println!("  Not found"),
    }
    println!("  ✅ Stopped at first match!");

    // ============================================================================
    // LAZY OPERATION 6: any - Existence Check
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 6: any (existence check)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Checking if any furniture exists...");
    let has_furniture = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .any();

    println!("  Has furniture: {}", has_furniture);
    println!("  ✅ Stopped immediately after finding first match!");

    // ============================================================================
    // LAZY OPERATION 7: count - Count Matching Items
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 7: count");
    println!("═══════════════════════════════════════════════════════════════\n");

    let electronics_count = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .count();

    println!("  Electronics count: {}", electronics_count);

    // ============================================================================
    // LAZY OPERATION 8: sum_by - Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 8: sum_by (aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_value: f64 = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .sum_by(Product::price_r());

    println!("  Total electronics value: ${:.2}", total_value);

    // ============================================================================
    // LAZY OPERATION 9: avg_by - Average
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 9: avg_by");
    println!("═══════════════════════════════════════════════════════════════\n");

    let avg_price = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .avg_by(Product::price_r())
        .unwrap_or(0.0);

    println!("  Average furniture price: ${:.2}", avg_price);

    // ============================================================================
    // LAZY OPERATION 10: min_by_float / max_by_float
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 10: min_by_float / max_by_float");
    println!("═══════════════════════════════════════════════════════════════\n");

    let min_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .min_by_float(Product::price_r())
        .unwrap_or(0.0);

    let max_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .max_by_float(Product::price_r())
        .unwrap_or(0.0);

    println!("  Price range for active products:");
    println!("    Min: ${:.2}", min_price);
    println!("    Max: ${:.2}", max_price);

    // ============================================================================
    // LAZY OPERATION 11: find - Find with Predicate
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 11: find (with predicate)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let high_rated = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .find(|item| item.rating > 4.7);

    if let Some(product) = high_rated {
        println!("  First highly-rated electronic:");
        println!("    {}: Rating {:.1}", product.name, product.rating);
    }

    // ============================================================================
    // LAZY OPERATION 12: for_each - Iteration
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 12: for_each (iteration)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  Low stock alerts:");
    LazyQuery::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .for_each(|product| {
            println!("    ⚠️  {}: Only {} in stock", product.name, product.stock);
        });

    // ============================================================================
    // LAZY OPERATION 13: fold - Custom Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 14: fold (custom aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_inventory_value = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .fold(0.0, |acc, product| {
            acc + (product.price * product.stock as f64)
        });

    println!("  Total inventory value: ${:.2}", total_inventory_value);

    // ============================================================================
    // LAZY OPERATION 14: all_match - Validation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 15: all_match (validation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let all_priced = LazyQuery::new(&products)
        .all_match(|item| item.price > 0.0);

    println!("  All products have valid prices: {}", all_priced);

    // ============================================================================
    // LAZY OPERATION 15: into_iter - For Loop
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 16: into_iter (for loop)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  High-value products (>$300):");
    for product in LazyQuery::new(&products)
        .where_(Product::price_r(), |&p| p > 300.0)
        .take_lazy(5)
    {
        println!("    • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // LAZY OPERATION 16: map_items - Transform
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 17: map_items (transformation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let price_tags: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .map_items(|p| format!("{}: ${:.2}", p.name, p.price))
        .take(5)
        .collect();

    println!("  Electronics price tags:");
    for tag in &price_tags {
        println!("    • {}", tag);
    }

    // ============================================================================
    // COMPLEX EXAMPLE: Multi-Stage Lazy Pipeline
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Multi-stage lazy pipeline");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building complex query:");
    println!("  1. Filter by category (Electronics)");
    println!("  2. Filter by price range ($50-$500)");
    println!("  3. Filter by rating (>4.5)");
    println!("  4. Select names");
    println!("  5. Take first 3");
    println!();

    let results: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p >= 50.0 && p <= 500.0)
        .where_(Product::rating_r(), |&r| r > 4.5)
        .select_lazy(Product::name_r())
        .take(3)
        .collect();

    println!("  Results:");
    for (i, name) in results.iter().enumerate() {
        println!("    {}. {}", i + 1, name);
    }
    println!("  ✅ All operations fused and executed lazily!");

    // ============================================================================
    // THREAD-SAFE UPDATES WITH RWLOCK
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Bonus: Thread-safe updates with RwLock");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Update a product through the Arc<RwLock>
    if let Some(product_arc) = product_map.get("PROD-002") {
        println!("Updating PROD-002 stock...");
        
        // Write lock for mutation
        if let Ok(mut product) = product_arc.write() {
            let old_stock = product.stock;
            product.stock = 25;
            println!("  Stock updated: {} → {}", old_stock, product.stock);
        }
    }

    // Query again to see the update
    let updated_products = extract_products(&product_map);
    let mouse = LazyQuery::new(&updated_products)
        .find(|p| p.id == 2);

    if let Some(product) = mouse {
        println!("  Verified update: {} now has {} in stock", product.name, product.stock);
    }

    // ============================================================================
    // PRACTICAL EXAMPLE: Price Analysis by Category
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Practical Example: Price analysis by category");
    println!("═══════════════════════════════════════════════════════════════\n");

    let categories = vec!["Electronics", "Furniture"];

    for category in categories {
        println!("  {} Statistics:", category);
        
        // Filter products by category first
        let cat_products: Vec<Product> = products.iter()
            .filter(|p| p.category == category)
            .cloned()
            .collect();

        let count = LazyQuery::new(&cat_products).count();
        let total = LazyQuery::new(&cat_products).sum_by(Product::price_r());
        let avg = LazyQuery::new(&cat_products).avg_by(Product::price_r()).unwrap_or(0.0);
        let min = LazyQuery::new(&cat_products).min_by_float(Product::price_r()).unwrap_or(0.0);
        let max = LazyQuery::new(&cat_products).max_by_float(Product::price_r()).unwrap_or(0.0);

        println!("    Count: {}", count);
        println!("    Total: ${:.2}", total);
        println!("    Average: ${:.2}", avg);
        println!("    Range: ${:.2} - ${:.2}\n", min, max);
    }

    // ============================================================================
    // COMBINING WITH HASHMAP OPERATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("HashMap Integration: Query by key patterns");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Filter HashMap by key pattern
    let electronics_keys: Vec<String> = product_map
        .iter()
        .filter(|(_key, value)| {
            // Read the value to check category
            if let Ok(guard) = value.read() {
                guard.category == "Electronics"
            } else {
                false
            }
        })
        .map(|(key, _value)| key.clone())
        .collect();

    println!("  Electronics product IDs:");
    for key in electronics_keys.iter().take(5) {
        println!("    • {}", key);
    }

    // ============================================================================
    // PERFORMANCE DEMONSTRATION
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Performance: Lazy vs Eager comparison");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first product with rating > 4.7 from {} products\n", products.len());

    println!("  Eager approach (hypothetical):");
    println!("    - Filter all {} products", products.len());
    println!("    - Collect filtered results");
    println!("    - Take first item");
    println!("    - Wasted work: Check all items\n");

    println!("  Lazy approach (actual):");
    let _first_rated = LazyQuery::new(&products)
        .where_(Product::rating_r(), |&r| r > 4.7)
        .first();
    println!("    - Starts checking products");
    println!("    - Stops at first match");
    println!("    - ✅ Early termination - checks ~3-5 items only!");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: All Lazy Operations Demonstrated                      ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Lazy Query Operations:");
    println!("   1. ✅ where_ - Lazy filtering");
    println!("   2. ✅ select_lazy - Lazy projection");
    println!("   3. ✅ take_lazy - Early termination");
    println!("   4. ✅ skip_lazy - Pagination");
    println!("   5. ✅ first - Short-circuit search");
    println!("   6. ✅ any - Existence check (short-circuit)");
    println!("   7. ✅ count - Count items");
    println!("   8. ✅ sum_by - Sum aggregation");
    println!("   9. ✅ avg_by - Average aggregation");
    println!("   10. ✅ min_by_float - Minimum value");
    println!("   11. ✅ max_by_float - Maximum value");
    println!("   12. ✅ find - Find with predicate (short-circuit)");
    println!("   13. ✅ for_each - Iteration");
    println!("   14. ✅ fold - Custom aggregation");
    println!("   15. ✅ all_match - Validation (short-circuit)");
    println!("   16. ✅ into_iter - For loop support");
    println!("   17. ✅ map_items - Transformation\n");

    println!("✅ Arc<RwLock<T>> Benefits:");
    println!("   • Thread-safe shared access");
    println!("   • Interior mutability");
    println!("   • Multiple readers, single writer");
    println!("   • Reference counting (Arc)");
    println!("   • Can be queried after extracting data\n");

    println!("✅ HashMap<K, Arc<RwLock<V>>> Benefits:");
    println!("   • Fast key-based lookup");
    println!("   • Thread-safe value access");
    println!("   • Can query all values");
    println!("   • Can filter by key patterns");
    println!("   • Perfect for shared state/caches\n");

    println!("🎯 Use Cases:");
    println!("   • Shared product catalogs");
    println!("   • User session stores");
    println!("   • Configuration caches");
    println!("   • Real-time inventory systems");
    println!("   • Multi-threaded data processing");
    println!("   • Web server state management\n");

    println!("✓ Arc<RwLock<T>> HashMap with all lazy operations demo complete!\n");
}

pub fn first(self) -> Option<&'a T>

Gets the first item (terminal operation - executes until first match).

Example

let first = query.first();

Examples found in repository

examples/individual_crates.rs (line 127)

fn main() {
    println!("Individual Crates Example");
    println!("=========================\n");
    println!("Using rust-queries-core + rust-queries-derive directly\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. QueryExt from rust_queries_core");
    println!("   products.query().where_(price > 100).all()");
    
    let query = products
        .query()  // From QueryExt trait
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. QueryBuilder from rust_queries_derive");
    println!("   Product::query(&products).where_(stock < 10).all()");
    
    let query2 = Product::query(&products)  // From QueryBuilder derive
        .where_(Product::stock_r(), |&s| s < 10);
    let low_stock = query2.all();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. LazyQuery from rust_queries_core");
    println!("   products.lazy_query().where_(...).collect()");
    
    let electronics: Vec<_> = products
        .lazy_query()  // From QueryExt trait
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .collect();
    
    println!("   Found {} electronics:", electronics.len());
    for product in electronics {
        println!("   - {}", product.name);
    }
    println!();

    println!("4. Aggregations with LazyQuery");
    println!("   products.lazy_query().sum_by(Product::price_r())");
    
    let total_value: f64 = products
        .lazy_query()
        .sum_by(Product::price_r());
    
    println!("   Total inventory value: ${:.2}", total_value);
    println!();

    println!("5. Early termination with lazy queries");
    println!("   products.lazy_query().where_(...).first()");
    
    if let Some(first_cheap) = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p < 50.0)
        .first()
    {
        println!("   First cheap product: {} (${:.2})", first_cheap.name, first_cheap.price);
    }
    println!();

    println!("6. Using Query (eager) from rust_queries_core");
    println!("   Query::new(&products).where_(...).count()");
    
    let query3 = Query::new(&products)  // Traditional approach
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query3.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ rust_queries_core provides: Query, LazyQuery, QueryExt");
    println!("✓ rust_queries_derive provides: #[derive(QueryBuilder)]");
    println!("✓ key_paths_derive provides: #[derive(Keypaths)]");
    println!("✓ All features work with individual crates!");
}

examples/derive_and_ext.rs (line 112)

fn main() {
    println!("Derive Macros and Extension Traits Example");
    println!("===========================================\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. Using Extension Trait - Direct .query() on Vec");
    println!("   Query: products.query().where_(price > 100).all()");
    
    let query = products
        .query()
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in &expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. Using Extension Trait - Direct .lazy_query() on Vec");
    println!("   Query: products.lazy_query().where_(stock < 10).collect()");
    
    let low_stock: Vec<_> = products
        .lazy_query()
        .where_(Product::stock_r(), |&s| s < 10)
        .collect();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in &low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. Using Extension Trait - Chained Operations");
    println!("   Query: products.lazy_query().where_(category == Electronics).take(2).select(name).collect()");
    
    let names: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(2)
        .select_lazy(Product::name_r())
        .collect();
    
    println!("   First 2 electronics:");
    for name in &names {
        println!("   - {}", name);
    }
    println!();

    println!("4. Using QueryBuilder Derive - Static Methods");
    println!("   Query: Product::query(&products).where_(price > 50).count()");
    
    let query4 = Product::query(&products)
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query4.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("5. Using QueryBuilder Derive - Lazy Static Methods");
    println!("   Query: Product::lazy_query(&products).first()");
    
    if let Some(first) = Product::lazy_query(&products).first() {
        println!("   First product: {} (${:.2})", first.name, first.price);
    }
    println!();

    println!("6. Complex Chain with Extension Trait");
    println!("   Query: products.lazy_query()");
    println!("          .where_(category == Electronics)");
    println!("          .where_(price < 500)");
    println!("          .map(|p| format!(\"{{}} - ${{:.2}}\", p.name, p.price))");
    println!("          .collect()");
    
    let formatted: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .map_items(|p| format!("{} - ${:.2}", p.name, p.price))
        .collect();
    
    println!("   Affordable electronics:");
    for item in &formatted {
        println!("   - {}", item);
    }
    println!();

    println!("7. Aggregation with Extension Trait");
    println!("   Query: products.lazy_query().sum_by(Product::stock())");
    
    let total_stock = products
        .lazy_query()
        .sum_by(Product::stock_r());
    
    println!("   Total stock across all products: {}", total_stock);
    println!();

    println!("8. Find with Extension Trait");
    println!("   Query: products.lazy_query().find(|p| p.name.contains(\"Chair\"))");
    
    if let Some(chair) = products.lazy_query().find(|p| p.name.contains("Chair")) {
        println!("   Found: {} in {}", chair.name, chair.category);
    }
    println!();

    println!("9. Early Termination with Extension Trait");
    println!("   Query: products.lazy_query().where_(price > 1000).any()");
    
    let has_luxury = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p > 1000.0)
        .any();
    
    println!("   Has products over $1000: {}", has_luxury);
    println!();

    println!("10. Slice Extension Trait");
    println!("    Query: (&products[..]).lazy_query().count()");
    
    let slice_count = (&products[..])
        .lazy_query()
        .count();
    
    println!("    Count from slice: {}", slice_count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ Extension trait QueryExt adds .query() and .lazy_query() to containers");
    println!("✓ Derive macro QueryBuilder adds static methods Product::query() and Product::lazy_query()");
    println!("✓ Both approaches provide the same query functionality");
    println!("✓ Extension trait is more ergonomic: products.query() vs Query::new(&products)");
    println!("✓ All iterator optimizations (fusion, early termination) still apply");
}

examples/lazy_evaluation.rs (line 189)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Lazy Query Evaluation Demo                                   ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    let products = create_products();
    println!("Created {} products\n", products.len());

    // ============================================================================
    // DEMO 1: Lazy Execution - Nothing Happens Until .collect()
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 1: Lazy execution - deferred until needed");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Building query (should execute nothing)...");
    let lazy_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            cat == "Electronics"
        });

    let evals_after_build = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Filter evaluations after building query: {}", evals_after_build);
    
    if evals_after_build == 0 {
        println!("  ✅ Confirmed: Query is lazy! Nothing executed yet.\n");
    }

    println!("Collecting results (now it executes)...");
    let results: Vec<_> = lazy_query.collect();

    let evals_after_collect = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Filter evaluations after collecting: {}", evals_after_collect);
    println!("  Results found: {}", results.len());
    println!("  ✅ Query executed exactly once, when needed!\n");

    // ============================================================================
    // DEMO 2: Early Termination - Stops as Soon as Enough Items Found
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 2: Early termination with .take()");
    println!("═══════════════════════════════════════════════════════════════\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);

    println!("Finding first 5 expensive items from 1000 products...");
    let first_5: Vec<_> = LazyQuery::new(&products)
        .where_(Product::price_r(), |p| expensive_check(p))
        .take_lazy(5)
        .collect();

    let ops = EXPENSIVE_OPERATIONS.load(Ordering::SeqCst);
    println!("  Found: {} items", first_5.len());
    println!("  Expensive operations performed: {}", ops);
    println!("  Items NOT checked: {} (stopped early!)", 1000 - ops);
    
    if ops < 1000 {
        println!("  ✅ Early termination worked! Didn't check all 1000 items.\n");
    }

    // ============================================================================
    // DEMO 3: Iterator Fusion - Rust Optimizes Chained Operations
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 3: Iterator fusion - chained operations optimized");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Chaining multiple operations...");
    let chained_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price > 200.0)
        .where_(Product::stock_r(), |&stock| stock > 10)
        .take_lazy(10);

    println!("  Built query with 3 filters + take(10)");
    println!("  ✅ No execution yet - all operations fused into one iterator\n");

    let results: Vec<_> = chained_query.collect();
    println!("  Executed: Found {} items", results.len());
    println!("  ✅ All filters applied in single pass!\n");

    // ============================================================================
    // DEMO 4: Lazy Projection - Only Extract What You Need
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 4: Lazy projection");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .select_lazy(Product::name_r())
        .take(5)  // Only process until we have 5
        .collect();

    println!("  Selected {} names", names.len());
    println!("  ✅ Only evaluated until 5 names found!\n");

    // ============================================================================
    // DEMO 5: Lazy Aggregation - Short-Circuit When Possible
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 5: Short-circuit with .any()");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Checking if ANY electronics exist (1000 items to search)...");
    let exists = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            cat == "Electronics"
        })
        .any();

    let checks = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Result: {}", exists);
    println!("  Items checked: {} out of 1000", checks);
    println!("  Items skipped: {} (short-circuited!)", 1000 - checks);
    
    if checks < 1000 {
        println!("  ✅ Short-circuit worked! Stopped as soon as first match found.\n");
    }

    // ============================================================================
    // DEMO 6: Lazy Find - Stops at First Match
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 6: .find() stops at first match");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Finding first product with price > 500...");
    let found = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            price > 500.0
        })
        .first();

    let checks = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    if let Some(product) = found {
        println!("  Found: {} (${:.2})", product.name, product.price);
    }
    println!("  Items checked: {} out of 1000", checks);
    println!("  ✅ Stopped immediately after finding first match!\n");

    // ============================================================================
    // DEMO 7: Composition - Build Queries Incrementally
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 7: Composable queries");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building base query...");
    let base_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Created base query (not executed)\n");

    println!("  Adding price filter...");
    let refined_query = base_query
        .where_(Product::price_r(), |&price| price > 100.0);

    println!("  Still not executed...\n");

    println!("  Adding stock filter and limiting...");
    let final_query = refined_query
        .where_(Product::stock_r(), |&stock| stock > 5)
        .take_lazy(10);

    println!("  Still not executed...\n");

    println!("  Executing...");
    let results: Vec<_> = final_query.collect();
    println!("  ✅ Executed once with all filters: Found {} items\n", results.len());

    // ============================================================================
    // DEMO 8: For Loop - Natural Iteration
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 8: Use in for loops");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Iterating over filtered products...");
    let mut count = 0;
    for product in LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
    {
        println!("  • {}: ${:.2}", product.name, product.price);
        count += 1;
    }
    println!("  ✅ Processed {} items lazily\n", count);

    // ============================================================================
    // DEMO 9: Performance Comparison
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 9: Performance benefit demonstration");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first expensive item from 1000 products\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);
    
    println!("Without lazy (hypothetical - check all, then take first):");
    println!("  Would check: 1000 items");
    println!("  Would find: ~300 matching items");
    println!("  Would return: 1 item");
    println!("  Wasted work: 299 items processed unnecessarily\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);
    
    println!("With lazy evaluation:");
    let _first = LazyQuery::new(&products)
        .where_(Product::price_r(), |p| expensive_check(p))
        .first();

    let ops = EXPENSIVE_OPERATIONS.load(Ordering::SeqCst);
    println!("  Checked: {} items", ops);
    println!("  Found: 1 item");
    println!("  Wasted work: 0 items");
    println!("  ✅ Efficiency gain: {}x faster!", 1000 / ops.max(1));

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Lazy Evaluation Benefits                                     ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Deferred Execution:");
    println!("   • No work until results needed");
    println!("   • Can build complex queries without performance cost\n");

    println!("✅ Early Termination:");
    println!("   • .take(n) stops after n items");
    println!("   • .first() stops after 1 item");
    println!("   • .any() stops after first match");
    println!("   • Massive performance win for large datasets\n");

    println!("✅ Iterator Fusion:");
    println!("   • Multiple filters combined into one pass");
    println!("   • Rust compiler optimizes chained operations");
    println!("   • No intermediate allocations\n");

    println!("✅ Composable:");
    println!("   • Build queries incrementally");
    println!("   • Reuse query fragments");
    println!("   • Clean separation of query building vs execution\n");

    println!("✅ Zero Overhead:");
    println!("   • Compiles to same code as manual loops");
    println!("   • No runtime cost for abstraction");
    println!("   • Pay only for what you use\n");

    println!("✓ Lazy evaluation demo complete!\n");
}

examples/custom_queryable.rs (line 401)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Custom Queryable Implementation Demo                         ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // ============================================================================
    // DEMO 1: PaginatedCollection
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 1: PaginatedCollection (custom container)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut paginated = PaginatedCollection::new(3); // 3 items per page
    
    paginated.add(create_sample_product(1, "Laptop", 999.0, "Electronics", true));
    paginated.add(create_sample_product(2, "Mouse", 29.0, "Electronics", true));
    paginated.add(create_sample_product(3, "Keyboard", 129.0, "Electronics", true));
    paginated.add(create_sample_product(4, "Desk", 299.0, "Furniture", true));
    paginated.add(create_sample_product(5, "Chair", 199.0, "Furniture", false));

    println!("  Created paginated collection:");
    println!("    Total items: {}", paginated.total_items());
    println!("    Pages: {}", paginated.pages.len());

    // Now we can query it using the Queryable trait!
    // Collect to owned Vec for querying
    let items: Vec<Product> = paginated.query_iter().cloned().collect();
    let query = Query::new(&items)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query.all();
    
    println!("\n  Querying paginated collection:");
    println!("    Electronics found: {}", electronics.len());
    for product in electronics {
        println!("      • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // DEMO 2: CircularBuffer
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 2: CircularBuffer (fixed capacity)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut circular = CircularBuffer::new(3); // Capacity: 3
    
    circular.push(create_sample_product(1, "Product 1", 100.0, "A", true));
    circular.push(create_sample_product(2, "Product 2", 200.0, "B", true));
    circular.push(create_sample_product(3, "Product 3", 300.0, "C", true));
    circular.push(create_sample_product(4, "Product 4", 400.0, "D", true)); // Pushes out Product 1

    println!("  Circular buffer (capacity 3, added 4 items):");
    println!("    Current size: {}", circular.len());

    // Query the circular buffer
    let circ_items: Vec<Product> = circular.query_iter().cloned().collect();
    let circ_query = Query::new(&circ_items);
    let avg_price = circ_query.avg(Product::price_r()).unwrap_or(0.0);
    
    println!("\n  Querying circular buffer:");
    println!("    Average price: ${:.2}", avg_price);
    println!("    Items:");
    for (i, product) in circ_items.iter().enumerate() {
        println!("      {}. {}: ${:.2}", i + 1, product.name, product.price);
    }

    // ============================================================================
    // DEMO 3: FilteredStorage
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 3: FilteredStorage (auto-filtering container)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut filtered = FilteredStorage::new(|p: &Product| p.price < 200.0);
    
    println!("  FilteredStorage (only accepts items < $200):");
    println!("    Adding Laptop ($999): {}", filtered.add(create_sample_product(1, "Laptop", 999.0, "Electronics", true)));
    println!("    Adding Mouse ($29): {}", filtered.add(create_sample_product(2, "Mouse", 29.0, "Electronics", true)));
    println!("    Adding Keyboard ($129): {}", filtered.add(create_sample_product(3, "Keyboard", 129.0, "Electronics", true)));
    println!("    Total stored: {}", filtered.len());

    // Query the filtered storage
    let filt_items: Vec<Product> = filtered.query_iter().cloned().collect();
    let filt_query = Query::new(&filt_items)
        .where_(Product::in_stock_r(), |&v| v);
    let in_stock = filt_query.all();
    
    println!("\n  Querying filtered storage:");
    println!("    In stock items: {}", in_stock.len());

    // ============================================================================
    // DEMO 4: CategoryIndex
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 4: CategoryIndex (indexed by category)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut category_index = CategoryIndex::new();
    
    category_index.add("Electronics".to_string(), create_sample_product(1, "Monitor", 349.0, "Electronics", true));
    category_index.add("Electronics".to_string(), create_sample_product(2, "Webcam", 79.0, "Electronics", true));
    category_index.add("Furniture".to_string(), create_sample_product(3, "Desk", 299.0, "Furniture", true));
    category_index.add("Furniture".to_string(), create_sample_product(4, "Lamp", 39.0, "Furniture", true));

    println!("  CategoryIndex:");
    println!("    Categories: {:?}", category_index.categories());
    println!("    Total items: {}", category_index.total_items());

    // Query across all categories
    let idx_items: Vec<Product> = category_index.query_iter().cloned().collect();
    let idx_query = Query::new(&idx_items);
    let expensive = idx_query
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive_items = expensive.all();
    
    println!("\n  Querying category index:");
    println!("    Expensive items (>$100): {}", expensive_items.len());
    for product in expensive_items {
        println!("      • {}: ${:.2} ({})", product.name, product.price, product.category);
    }

    // ============================================================================
    // DEMO 5: LazyLoader
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 5: LazyLoader (simulated lazy loading)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let loader = LazyLoader::new(vec![
        create_sample_product(1, "Item 1", 50.0, "A", true),
        create_sample_product(2, "Item 2", 150.0, "B", true),
        create_sample_product(3, "Item 3", 250.0, "C", true),
    ]);

    println!("  LazyLoader:");
    println!("    Total available: {}", loader.total_count());
    println!("    Currently loaded: {}", loader.loaded_count());

    // Query loaded items
    let loader_items: Vec<Product> = loader.query_iter().cloned().collect();
    let loader_query = Query::new(&loader_items);
    let total_value = loader_query.sum(Product::price_r());
    
    println!("\n  Querying lazy loader:");
    println!("    Total value: ${:.2}", total_value);

    // ============================================================================
    // DEMO 6: Custom Container with LazyQuery
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 6: Using LazyQuery with custom containers");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut circular = CircularBuffer::new(5);
    for i in 1..=10 {
        circular.push(create_sample_product(
            i,
            &format!("Product {}", i),
            i as f64 * 50.0,
            if i % 2 == 0 { "Even" } else { "Odd" },
            true,
        ));
    }

    println!("  Circular buffer (capacity 5, added 10 items):");
    println!("    Current size: {}", circular.len());

    // Use LazyQuery for early termination!
    let circ_vec: Vec<Product> = circular.query_iter().cloned().collect();
    let first_expensive = LazyQuery::new(&circ_vec)
        .where_(Product::price_r(), |&p| p > 300.0)
        .first();

    if let Some(product) = first_expensive {
        println!("\n  First expensive item (lazy query):");
        println!("    {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // DEMO 7: Implementing Queryable for Wrapper Types
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 7: Queryable for wrapper types");
    println!("═══════════════════════════════════════════════════════════════\n");

    /// A simple wrapper around Vec with metadata
    struct VersionedCollection<T> {
        items: Vec<T>,
        version: u32,
        last_modified: String,
    }

    impl<T> Queryable<T> for VersionedCollection<T> {
        fn query_iter(&self) -> Box<dyn Iterator<Item = &T> + '_> {
            Box::new(self.items.iter())
        }
    }

    let versioned = VersionedCollection {
        items: vec![
            create_sample_product(1, "V1 Product", 99.0, "Test", true),
            create_sample_product(2, "V2 Product", 199.0, "Test", true),
        ],
        version: 2,
        last_modified: "2025-10-11".to_string(),
    };

    println!("  VersionedCollection:");
    println!("    Version: {}", versioned.version);
    println!("    Last modified: {}", versioned.last_modified);

    let versioned_items: Vec<Product> = versioned.query_iter().cloned().collect();
    let query = Query::new(&versioned_items);
    println!("    Items: {}", query.count());

    // ============================================================================
    // DEMO 8: Real-World Example - Cache with TTL
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 8: Cache container (real-world example)");
    println!("═══════════════════════════════════════════════════════════════\n");

    use std::time::{Duration, SystemTime};

    struct CachedItem<T> {
        item: T,
        inserted_at: SystemTime,
        ttl: Duration,
    }

    struct Cache<T> {
        items: Vec<CachedItem<T>>,
    }

    impl<T> Cache<T> {
        fn new() -> Self {
            Self { items: Vec::new() }
        }

        fn insert(&mut self, item: T, ttl: Duration) {
            self.items.push(CachedItem {
                item,
                inserted_at: SystemTime::now(),
                ttl,
            });
        }

        fn valid_items(&self) -> Vec<&T> {
            let now = SystemTime::now();
            self.items
                .iter()
                .filter(|cached| {
                    now.duration_since(cached.inserted_at)
                        .map_or(false, |elapsed| elapsed < cached.ttl)
                })
                .map(|cached| &cached.item)
                .collect()
        }
    }

    // Implement Queryable to query only valid (non-expired) items
    impl<T> Queryable<T> for Cache<T> {
        fn query_iter(&self) -> Box<dyn Iterator<Item = &T> + '_> {
            let now = SystemTime::now();
            Box::new(
                self.items
                    .iter()
                    .filter(move |cached| {
                        now.duration_since(cached.inserted_at)
                            .map_or(false, |elapsed| elapsed < cached.ttl)
                    })
                    .map(|cached| &cached.item),
            )
        }
    }

    let mut cache = Cache::new();
    cache.insert(create_sample_product(1, "Cached Item 1", 100.0, "A", true), Duration::from_secs(60));
    cache.insert(create_sample_product(2, "Cached Item 2", 200.0, "B", true), Duration::from_secs(60));

    let valid = cache.valid_items();
    println!("  Cache:");
    println!("    Total items: {}", cache.items.len());
    println!("    Valid items: {}", valid.len());

    // Query the cache
    let cache_items: Vec<Product> = cache.query_iter().cloned().collect();
    let cache_query = Query::new(&cache_items);
    println!("    Queryable items: {}", cache_query.count());

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: Implementing Queryable                              ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ How to make any container queryable:\n");
    println!("  1. Implement the Queryable<T> trait:");
    println!("     ```rust");
    println!("     impl<T> Queryable<T> for MyContainer<T> {{");
    println!("         fn query_iter(&self) -> Box<dyn Iterator<Item = &T> + '_> {{");
    println!("             Box::new(self.items.iter())");
    println!("         }}");
    println!("     }}");
    println!("     ```\n");

    println!("  2. Convert to Vec or slice for querying:");
    println!("     ```rust");
    println!("     let items: Vec<&Product> = container.query_iter().collect();");
    println!("     let query = Query::new(&items);");
    println!("     ```\n");

    println!("  3. Now use all query operations:");
    println!("     ```rust");
    println!("     let results = query.where_(...).all();");
    println!("     let count = query.count();");
    println!("     let total = query.sum(field);");
    println!("     ```\n");

    println!("📝 Custom containers demonstrated:");
    println!("   • PaginatedCollection - Items stored in pages");
    println!("   • CircularBuffer - Fixed-capacity FIFO buffer");
    println!("   • FilteredStorage - Auto-filtering container");
    println!("   • CategoryIndex - Indexed by category");
    println!("   • LazyLoader - Simulated lazy loading");
    println!("   • VersionedCollection - Wrapper with metadata");
    println!("   • Cache - TTL-based cache\n");

    println!("💡 Use cases:");
    println!("   • Database result wrappers");
    println!("   • Custom data structures");
    println!("   • Specialized collections");
    println!("   • Caches and buffers");
    println!("   • Event streams");
    println!("   • Any container that holds items!\n");

    println!("✓ Custom Queryable demo complete!\n");
}

examples/arc_rwlock_hashmap.rs (line 162)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Arc<RwLock<T>> HashMap Lazy Query Demo                         ║");
    println!("║  Thread-safe shared data with lazy evaluation                   ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    let product_map = create_sample_data();
    println!("Created product catalog:");
    println!("  Total products: {}", product_map.len());
    println!("  Keys: {:?}\n", product_map.keys().take(3).collect::<Vec<_>>());

    // Extract products for querying
    let products = extract_products(&product_map);
    println!("Extracted {} products from Arc<RwLock<Product>>\n", products.len());

    // ============================================================================
    // LAZY OPERATION 1: where_ - Lazy Filtering
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 1: where_ (filtering)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building filtered query (nothing executes yet)...");
    let electronics_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::active_r(), |&active| active)
        .where_(Product::stock_r(), |&stock| stock > 20);

    println!("  ✅ Query built (deferred execution)\n");

    println!("Collecting results (executes now)...");
    let electronics: Vec<_> = electronics_query.collect();
    println!("  Found {} electronics in stock", electronics.len());
    for p in &electronics {
        println!("    • {}: {} in stock", p.name, p.stock);
    }

    // ============================================================================
    // LAZY OPERATION 2: select_lazy - Lazy Projection
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 2: select_lazy (projection)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting product names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .select_lazy(Product::name_r())
        .collect();

    println!("  Furniture names ({}):", names.len());
    for name in &names {
        println!("    • {}", name);
    }

    // ============================================================================
    // LAZY OPERATION 3: take_lazy - Early Termination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 3: take_lazy (early termination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting first 3 electronics...");
    let first_3: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
        .collect();

    println!("  First 3 electronics:");
    for (i, p) in first_3.iter().enumerate() {
        println!("    {}. {} - ${:.2}", i + 1, p.name, p.price);
    }
    println!("  ✅ Stopped after finding 3 items!");

    // ============================================================================
    // LAZY OPERATION 4: skip_lazy - Pagination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 4: skip_lazy (pagination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting page 2 (skip 3, take 3)...");
    let page_2: Vec<_> = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .skip_lazy(3)
        .take_lazy(3)
        .collect();

    println!("  Page 2 items:");
    for (i, p) in page_2.iter().enumerate() {
        println!("    {}. {}", i + 4, p.name);
    }

    // ============================================================================
    // LAZY OPERATION 5: first - Short-Circuit Search
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 5: first (short-circuit)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Finding first expensive item (>$1000)...");
    let expensive = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0)
        .first();

    match expensive {
        Some(p) => println!("  Found: {} - ${:.2}", p.name, p.price),
        None => println!("  Not found"),
    }
    println!("  ✅ Stopped at first match!");

    // ============================================================================
    // LAZY OPERATION 6: any - Existence Check
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 6: any (existence check)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Checking if any furniture exists...");
    let has_furniture = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .any();

    println!("  Has furniture: {}", has_furniture);
    println!("  ✅ Stopped immediately after finding first match!");

    // ============================================================================
    // LAZY OPERATION 7: count - Count Matching Items
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 7: count");
    println!("═══════════════════════════════════════════════════════════════\n");

    let electronics_count = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .count();

    println!("  Electronics count: {}", electronics_count);

    // ============================================================================
    // LAZY OPERATION 8: sum_by - Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 8: sum_by (aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_value: f64 = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .sum_by(Product::price_r());

    println!("  Total electronics value: ${:.2}", total_value);

    // ============================================================================
    // LAZY OPERATION 9: avg_by - Average
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 9: avg_by");
    println!("═══════════════════════════════════════════════════════════════\n");

    let avg_price = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .avg_by(Product::price_r())
        .unwrap_or(0.0);

    println!("  Average furniture price: ${:.2}", avg_price);

    // ============================================================================
    // LAZY OPERATION 10: min_by_float / max_by_float
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 10: min_by_float / max_by_float");
    println!("═══════════════════════════════════════════════════════════════\n");

    let min_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .min_by_float(Product::price_r())
        .unwrap_or(0.0);

    let max_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .max_by_float(Product::price_r())
        .unwrap_or(0.0);

    println!("  Price range for active products:");
    println!("    Min: ${:.2}", min_price);
    println!("    Max: ${:.2}", max_price);

    // ============================================================================
    // LAZY OPERATION 11: find - Find with Predicate
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 11: find (with predicate)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let high_rated = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .find(|item| item.rating > 4.7);

    if let Some(product) = high_rated {
        println!("  First highly-rated electronic:");
        println!("    {}: Rating {:.1}", product.name, product.rating);
    }

    // ============================================================================
    // LAZY OPERATION 12: for_each - Iteration
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 12: for_each (iteration)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  Low stock alerts:");
    LazyQuery::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .for_each(|product| {
            println!("    ⚠️  {}: Only {} in stock", product.name, product.stock);
        });

    // ============================================================================
    // LAZY OPERATION 13: fold - Custom Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 14: fold (custom aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_inventory_value = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .fold(0.0, |acc, product| {
            acc + (product.price * product.stock as f64)
        });

    println!("  Total inventory value: ${:.2}", total_inventory_value);

    // ============================================================================
    // LAZY OPERATION 14: all_match - Validation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 15: all_match (validation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let all_priced = LazyQuery::new(&products)
        .all_match(|item| item.price > 0.0);

    println!("  All products have valid prices: {}", all_priced);

    // ============================================================================
    // LAZY OPERATION 15: into_iter - For Loop
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 16: into_iter (for loop)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  High-value products (>$300):");
    for product in LazyQuery::new(&products)
        .where_(Product::price_r(), |&p| p > 300.0)
        .take_lazy(5)
    {
        println!("    • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // LAZY OPERATION 16: map_items - Transform
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 17: map_items (transformation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let price_tags: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .map_items(|p| format!("{}: ${:.2}", p.name, p.price))
        .take(5)
        .collect();

    println!("  Electronics price tags:");
    for tag in &price_tags {
        println!("    • {}", tag);
    }

    // ============================================================================
    // COMPLEX EXAMPLE: Multi-Stage Lazy Pipeline
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Multi-stage lazy pipeline");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building complex query:");
    println!("  1. Filter by category (Electronics)");
    println!("  2. Filter by price range ($50-$500)");
    println!("  3. Filter by rating (>4.5)");
    println!("  4. Select names");
    println!("  5. Take first 3");
    println!();

    let results: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p >= 50.0 && p <= 500.0)
        .where_(Product::rating_r(), |&r| r > 4.5)
        .select_lazy(Product::name_r())
        .take(3)
        .collect();

    println!("  Results:");
    for (i, name) in results.iter().enumerate() {
        println!("    {}. {}", i + 1, name);
    }
    println!("  ✅ All operations fused and executed lazily!");

    // ============================================================================
    // THREAD-SAFE UPDATES WITH RWLOCK
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Bonus: Thread-safe updates with RwLock");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Update a product through the Arc<RwLock>
    if let Some(product_arc) = product_map.get("PROD-002") {
        println!("Updating PROD-002 stock...");
        
        // Write lock for mutation
        if let Ok(mut product) = product_arc.write() {
            let old_stock = product.stock;
            product.stock = 25;
            println!("  Stock updated: {} → {}", old_stock, product.stock);
        }
    }

    // Query again to see the update
    let updated_products = extract_products(&product_map);
    let mouse = LazyQuery::new(&updated_products)
        .find(|p| p.id == 2);

    if let Some(product) = mouse {
        println!("  Verified update: {} now has {} in stock", product.name, product.stock);
    }

    // ============================================================================
    // PRACTICAL EXAMPLE: Price Analysis by Category
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Practical Example: Price analysis by category");
    println!("═══════════════════════════════════════════════════════════════\n");

    let categories = vec!["Electronics", "Furniture"];

    for category in categories {
        println!("  {} Statistics:", category);
        
        // Filter products by category first
        let cat_products: Vec<Product> = products.iter()
            .filter(|p| p.category == category)
            .cloned()
            .collect();

        let count = LazyQuery::new(&cat_products).count();
        let total = LazyQuery::new(&cat_products).sum_by(Product::price_r());
        let avg = LazyQuery::new(&cat_products).avg_by(Product::price_r()).unwrap_or(0.0);
        let min = LazyQuery::new(&cat_products).min_by_float(Product::price_r()).unwrap_or(0.0);
        let max = LazyQuery::new(&cat_products).max_by_float(Product::price_r()).unwrap_or(0.0);

        println!("    Count: {}", count);
        println!("    Total: ${:.2}", total);
        println!("    Average: ${:.2}", avg);
        println!("    Range: ${:.2} - ${:.2}\n", min, max);
    }

    // ============================================================================
    // COMBINING WITH HASHMAP OPERATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("HashMap Integration: Query by key patterns");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Filter HashMap by key pattern
    let electronics_keys: Vec<String> = product_map
        .iter()
        .filter(|(_key, value)| {
            // Read the value to check category
            if let Ok(guard) = value.read() {
                guard.category == "Electronics"
            } else {
                false
            }
        })
        .map(|(key, _value)| key.clone())
        .collect();

    println!("  Electronics product IDs:");
    for key in electronics_keys.iter().take(5) {
        println!("    • {}", key);
    }

    // ============================================================================
    // PERFORMANCE DEMONSTRATION
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Performance: Lazy vs Eager comparison");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first product with rating > 4.7 from {} products\n", products.len());

    println!("  Eager approach (hypothetical):");
    println!("    - Filter all {} products", products.len());
    println!("    - Collect filtered results");
    println!("    - Take first item");
    println!("    - Wasted work: Check all items\n");

    println!("  Lazy approach (actual):");
    let _first_rated = LazyQuery::new(&products)
        .where_(Product::rating_r(), |&r| r > 4.7)
        .first();
    println!("    - Starts checking products");
    println!("    - Stops at first match");
    println!("    - ✅ Early termination - checks ~3-5 items only!");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: All Lazy Operations Demonstrated                      ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Lazy Query Operations:");
    println!("   1. ✅ where_ - Lazy filtering");
    println!("   2. ✅ select_lazy - Lazy projection");
    println!("   3. ✅ take_lazy - Early termination");
    println!("   4. ✅ skip_lazy - Pagination");
    println!("   5. ✅ first - Short-circuit search");
    println!("   6. ✅ any - Existence check (short-circuit)");
    println!("   7. ✅ count - Count items");
    println!("   8. ✅ sum_by - Sum aggregation");
    println!("   9. ✅ avg_by - Average aggregation");
    println!("   10. ✅ min_by_float - Minimum value");
    println!("   11. ✅ max_by_float - Maximum value");
    println!("   12. ✅ find - Find with predicate (short-circuit)");
    println!("   13. ✅ for_each - Iteration");
    println!("   14. ✅ fold - Custom aggregation");
    println!("   15. ✅ all_match - Validation (short-circuit)");
    println!("   16. ✅ into_iter - For loop support");
    println!("   17. ✅ map_items - Transformation\n");

    println!("✅ Arc<RwLock<T>> Benefits:");
    println!("   • Thread-safe shared access");
    println!("   • Interior mutability");
    println!("   • Multiple readers, single writer");
    println!("   • Reference counting (Arc)");
    println!("   • Can be queried after extracting data\n");

    println!("✅ HashMap<K, Arc<RwLock<V>>> Benefits:");
    println!("   • Fast key-based lookup");
    println!("   • Thread-safe value access");
    println!("   • Can query all values");
    println!("   • Can filter by key patterns");
    println!("   • Perfect for shared state/caches\n");

    println!("🎯 Use Cases:");
    println!("   • Shared product catalogs");
    println!("   • User session stores");
    println!("   • Configuration caches");
    println!("   • Real-time inventory systems");
    println!("   • Multi-threaded data processing");
    println!("   • Web server state management\n");

    println!("✓ Arc<RwLock<T>> HashMap with all lazy operations demo complete!\n");
}

pub fn count(self) -> usize

Counts items (terminal operation - executes query).

Example

let count = query.count();

Examples found in repository

examples/derive_and_ext.rs (line 171)

fn main() {
    println!("Derive Macros and Extension Traits Example");
    println!("===========================================\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. Using Extension Trait - Direct .query() on Vec");
    println!("   Query: products.query().where_(price > 100).all()");
    
    let query = products
        .query()
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in &expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. Using Extension Trait - Direct .lazy_query() on Vec");
    println!("   Query: products.lazy_query().where_(stock < 10).collect()");
    
    let low_stock: Vec<_> = products
        .lazy_query()
        .where_(Product::stock_r(), |&s| s < 10)
        .collect();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in &low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. Using Extension Trait - Chained Operations");
    println!("   Query: products.lazy_query().where_(category == Electronics).take(2).select(name).collect()");
    
    let names: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(2)
        .select_lazy(Product::name_r())
        .collect();
    
    println!("   First 2 electronics:");
    for name in &names {
        println!("   - {}", name);
    }
    println!();

    println!("4. Using QueryBuilder Derive - Static Methods");
    println!("   Query: Product::query(&products).where_(price > 50).count()");
    
    let query4 = Product::query(&products)
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query4.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("5. Using QueryBuilder Derive - Lazy Static Methods");
    println!("   Query: Product::lazy_query(&products).first()");
    
    if let Some(first) = Product::lazy_query(&products).first() {
        println!("   First product: {} (${:.2})", first.name, first.price);
    }
    println!();

    println!("6. Complex Chain with Extension Trait");
    println!("   Query: products.lazy_query()");
    println!("          .where_(category == Electronics)");
    println!("          .where_(price < 500)");
    println!("          .map(|p| format!(\"{{}} - ${{:.2}}\", p.name, p.price))");
    println!("          .collect()");
    
    let formatted: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .map_items(|p| format!("{} - ${:.2}", p.name, p.price))
        .collect();
    
    println!("   Affordable electronics:");
    for item in &formatted {
        println!("   - {}", item);
    }
    println!();

    println!("7. Aggregation with Extension Trait");
    println!("   Query: products.lazy_query().sum_by(Product::stock())");
    
    let total_stock = products
        .lazy_query()
        .sum_by(Product::stock_r());
    
    println!("   Total stock across all products: {}", total_stock);
    println!();

    println!("8. Find with Extension Trait");
    println!("   Query: products.lazy_query().find(|p| p.name.contains(\"Chair\"))");
    
    if let Some(chair) = products.lazy_query().find(|p| p.name.contains("Chair")) {
        println!("   Found: {} in {}", chair.name, chair.category);
    }
    println!();

    println!("9. Early Termination with Extension Trait");
    println!("   Query: products.lazy_query().where_(price > 1000).any()");
    
    let has_luxury = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p > 1000.0)
        .any();
    
    println!("   Has products over $1000: {}", has_luxury);
    println!();

    println!("10. Slice Extension Trait");
    println!("    Query: (&products[..]).lazy_query().count()");
    
    let slice_count = (&products[..])
        .lazy_query()
        .count();
    
    println!("    Count from slice: {}", slice_count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ Extension trait QueryExt adds .query() and .lazy_query() to containers");
    println!("✓ Derive macro QueryBuilder adds static methods Product::query() and Product::lazy_query()");
    println!("✓ Both approaches provide the same query functionality");
    println!("✓ Extension trait is more ergonomic: products.query() vs Query::new(&products)");
    println!("✓ All iterator optimizations (fusion, early termination) still apply");
}

examples/container_support.rs (line 54)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Container Support Demo                                       ║");
    println!("║  Query various collection types                               ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // ============================================================================
    // CONTAINER 1: Vec<T>
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Container 1: Vec<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let vec_products = vec![
        create_sample_product(1, "Laptop", 999, "Electronics"),
        create_sample_product(2, "Mouse", 29, "Electronics"),
        create_sample_product(3, "Desk", 299, "Furniture"),
    ];

    // Query Vec directly
    let vec_query = Query::new(&vec_products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let vec_results = vec_query.all();
    println!("  Vec: Found {} electronics", vec_results.len());

    // Lazy query on Vec
    let lazy_count = LazyQuery::new(&vec_products)
        .where_(Product::price_r(), |&p| p < 100)
        .count();
    println!("  Vec (lazy): {} items under $100", lazy_count);

    // ============================================================================
    // CONTAINER 2: VecDeque<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 2: VecDeque<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut deque_products = VecDeque::new();
    deque_products.push_back(create_sample_product(1, "Keyboard", 129, "Electronics"));
    deque_products.push_back(create_sample_product(2, "Monitor", 349, "Electronics"));
    deque_products.push_back(create_sample_product(3, "Chair", 199, "Furniture"));

    // Convert to owned Vec for querying
    let deque_vec: Vec<Product> = deque_products.iter().cloned().collect();
    let deque_query = Query::new(&deque_vec);
    let deque_count = deque_query.count();
    println!("  VecDeque: {} total items", deque_count);

    // More efficient: use make_contiguous for zero-copy slice access
    let contiguous = deque_products.make_contiguous();
    let contiguous_query = Query::new(contiguous);
    println!("  VecDeque (zero-copy): {} items", contiguous_query.count());

    // ============================================================================
    // CONTAINER 3: HashSet<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 3: HashSet<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut set_products = HashSet::new();
    set_products.insert(create_sample_product(1, "Tablet", 499, "Electronics"));
    set_products.insert(create_sample_product(2, "Phone", 799, "Electronics"));
    set_products.insert(create_sample_product(3, "Lamp", 39, "Furniture"));

    // Collect from HashSet to Vec for querying
    let set_vec: Vec<Product> = set_products.iter().cloned().collect();
    let set_query = Query::new(&set_vec)
        .where_(Product::price_r(), |&p| p > 500);
    let expensive = set_query.all();
    println!("  HashSet: {} expensive items", expensive.len());

    // Lazy on HashSet (convert to owned Vec first)
    let set_owned: Vec<Product> = set_products.iter().cloned().collect();
    let lazy_set: Vec<_> = LazyQuery::new(&set_owned)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .collect();
    println!("  HashSet (lazy): {} electronics", lazy_set.len());

    // ============================================================================
    // CONTAINER 4: BTreeSet<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 4: BTreeSet<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut btree_set = BTreeSet::new();
    btree_set.insert(create_sample_product(1, "Webcam", 79, "Electronics"));
    btree_set.insert(create_sample_product(2, "Microphone", 129, "Electronics"));
    btree_set.insert(create_sample_product(3, "Bookshelf", 149, "Furniture"));

    let btree_vec: Vec<Product> = btree_set.iter().cloned().collect();
    let btree_query = Query::new(&btree_vec);
    println!("  BTreeSet: {} total items (sorted order!)", btree_query.count());
    
    // BTreeSet items are in sorted order
    for (i, item) in btree_vec.iter().take(3).enumerate() {
        println!("    {}. {} (ID: {})", i + 1, item.name, item.id);
    }

    // ============================================================================
    // CONTAINER 5: HashMap<K, V> - Query Values
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 5: HashMap<K, V> - Querying values");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut map_products = HashMap::new();
    map_products.insert("prod1", create_sample_product(1, "Speaker", 199, "Electronics"));
    map_products.insert("prod2", create_sample_product(2, "Headphones", 149, "Electronics"));
    map_products.insert("prod3", create_sample_product(3, "Ottoman", 249, "Furniture"));

    // Query HashMap values (convert to owned Vec)
    let map_vec: Vec<Product> = map_products.values().cloned().collect();
    let map_query = Query::new(&map_vec)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = map_query.all();
    println!("  HashMap: {} electronics", electronics.len());

    // ============================================================================
    // CONTAINER 6: BTreeMap<K, V> - Query Values
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 6: BTreeMap<K, V> - Querying values");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut btree_map = BTreeMap::new();
    btree_map.insert(1, create_sample_product(1, "Router", 89, "Electronics"));
    btree_map.insert(2, create_sample_product(2, "Switch", 129, "Electronics"));
    btree_map.insert(3, create_sample_product(3, "Sofa", 899, "Furniture"));

    let btree_map_vec: Vec<Product> = btree_map.values().cloned().collect();
    let btree_map_query = Query::new(&btree_map_vec);
    let avg_price = btree_map_query.sum(Product::price_r()) as f64 / btree_map.len() as f64;
    println!("  BTreeMap: Average price ${:.2}", avg_price);

    // ============================================================================
    // CONTAINER 7: Arrays [T; N]
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 7: Arrays [T; N]");
    println!("═══════════════════════════════════════════════════════════════\n");

    let array_products = [
        create_sample_product(1, "USB Cable", 15, "Electronics"),
        create_sample_product(2, "HDMI Cable", 25, "Electronics"),
        create_sample_product(3, "Power Strip", 35, "Electronics"),
    ];

    // Query array directly (as slice)
    let array_query = Query::new(&array_products);
    let total = array_query.sum(Product::price_r());
    println!("  Array: Total value ${}", total);

    // Lazy on array
    let lazy_array: Vec<_> = LazyQuery::new(&array_products)
        .where_(Product::price_r(), |&p| p > 20)
        .collect();
    println!("  Array (lazy): {} items over $20", lazy_array.len());

    // ============================================================================
    // CONTAINER 8: LinkedList<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 8: LinkedList<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut list_products = LinkedList::new();
    list_products.push_back(create_sample_product(1, "SSD", 159, "Electronics"));
    list_products.push_back(create_sample_product(2, "HDD", 79, "Electronics"));

    let list_vec: Vec<Product> = list_products.iter().cloned().collect();
    let list_query = Query::new(&list_vec);
    println!("  LinkedList: {} items", list_query.count());

    // ============================================================================
    // CONTAINER 9: Option<T> and Result<T, E>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 9: Option<T> and Result<T, E>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let maybe_product = Some(create_sample_product(1, "Mystery Box", 99, "Special"));
    
    if let Some(ref product) = maybe_product {
        let option_query = Query::new(std::slice::from_ref(product));
        println!("  Option (Some): {} items", option_query.count());
    }

    let none_product: Option<Product> = None;
    let none_count = none_product.iter().count();
    println!("  Option (None): {} items", none_count);

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Supported Containers Summary                                  ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Supported container types:");
    println!("   • Vec<T>              - Standard vector");
    println!("   • &[T]                - Slices");
    println!("   • [T; N]              - Fixed-size arrays");
    println!("   • VecDeque<T>         - Double-ended queue");
    println!("   • LinkedList<T>       - Doubly-linked list");
    println!("   • HashSet<T>          - Unordered set");
    println!("   • BTreeSet<T>         - Ordered set");
    println!("   • HashMap<K, V>       - Query values");
    println!("   • BTreeMap<K, V>      - Query values (sorted)");
    println!("   • Option<T>           - 0 or 1 item");
    println!("   • Result<T, E>        - 0 or 1 item\n");

    println!("📝 Usage patterns:");
    println!("   • Direct: Query::new(&container) for Vec, slices, arrays");
    println!("   • Convert: Collect to Vec for Sets and Maps");
    println!("   • Lazy: LazyQuery::new(&slice) for any slice\n");

    println!("💡 Tips:");
    println!("   • Vec/slice: Direct support, most efficient");
    println!("   • Sets: Iterate to Vec, then query");
    println!("   • Maps: Use .values().collect() to query values");
    println!("   • VecDeque: Use .as_slices() for zero-copy");
    println!("   • For custom types: Implement Queryable trait\n");

    println!("✓ Container support demo complete!\n");
}

examples/arc_rwlock_hashmap.rs (line 194)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Arc<RwLock<T>> HashMap Lazy Query Demo                         ║");
    println!("║  Thread-safe shared data with lazy evaluation                   ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    let product_map = create_sample_data();
    println!("Created product catalog:");
    println!("  Total products: {}", product_map.len());
    println!("  Keys: {:?}\n", product_map.keys().take(3).collect::<Vec<_>>());

    // Extract products for querying
    let products = extract_products(&product_map);
    println!("Extracted {} products from Arc<RwLock<Product>>\n", products.len());

    // ============================================================================
    // LAZY OPERATION 1: where_ - Lazy Filtering
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 1: where_ (filtering)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building filtered query (nothing executes yet)...");
    let electronics_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::active_r(), |&active| active)
        .where_(Product::stock_r(), |&stock| stock > 20);

    println!("  ✅ Query built (deferred execution)\n");

    println!("Collecting results (executes now)...");
    let electronics: Vec<_> = electronics_query.collect();
    println!("  Found {} electronics in stock", electronics.len());
    for p in &electronics {
        println!("    • {}: {} in stock", p.name, p.stock);
    }

    // ============================================================================
    // LAZY OPERATION 2: select_lazy - Lazy Projection
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 2: select_lazy (projection)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting product names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .select_lazy(Product::name_r())
        .collect();

    println!("  Furniture names ({}):", names.len());
    for name in &names {
        println!("    • {}", name);
    }

    // ============================================================================
    // LAZY OPERATION 3: take_lazy - Early Termination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 3: take_lazy (early termination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting first 3 electronics...");
    let first_3: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
        .collect();

    println!("  First 3 electronics:");
    for (i, p) in first_3.iter().enumerate() {
        println!("    {}. {} - ${:.2}", i + 1, p.name, p.price);
    }
    println!("  ✅ Stopped after finding 3 items!");

    // ============================================================================
    // LAZY OPERATION 4: skip_lazy - Pagination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 4: skip_lazy (pagination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting page 2 (skip 3, take 3)...");
    let page_2: Vec<_> = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .skip_lazy(3)
        .take_lazy(3)
        .collect();

    println!("  Page 2 items:");
    for (i, p) in page_2.iter().enumerate() {
        println!("    {}. {}", i + 4, p.name);
    }

    // ============================================================================
    // LAZY OPERATION 5: first - Short-Circuit Search
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 5: first (short-circuit)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Finding first expensive item (>$1000)...");
    let expensive = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0)
        .first();

    match expensive {
        Some(p) => println!("  Found: {} - ${:.2}", p.name, p.price),
        None => println!("  Not found"),
    }
    println!("  ✅ Stopped at first match!");

    // ============================================================================
    // LAZY OPERATION 6: any - Existence Check
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 6: any (existence check)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Checking if any furniture exists...");
    let has_furniture = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .any();

    println!("  Has furniture: {}", has_furniture);
    println!("  ✅ Stopped immediately after finding first match!");

    // ============================================================================
    // LAZY OPERATION 7: count - Count Matching Items
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 7: count");
    println!("═══════════════════════════════════════════════════════════════\n");

    let electronics_count = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .count();

    println!("  Electronics count: {}", electronics_count);

    // ============================================================================
    // LAZY OPERATION 8: sum_by - Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 8: sum_by (aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_value: f64 = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .sum_by(Product::price_r());

    println!("  Total electronics value: ${:.2}", total_value);

    // ============================================================================
    // LAZY OPERATION 9: avg_by - Average
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 9: avg_by");
    println!("═══════════════════════════════════════════════════════════════\n");

    let avg_price = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .avg_by(Product::price_r())
        .unwrap_or(0.0);

    println!("  Average furniture price: ${:.2}", avg_price);

    // ============================================================================
    // LAZY OPERATION 10: min_by_float / max_by_float
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 10: min_by_float / max_by_float");
    println!("═══════════════════════════════════════════════════════════════\n");

    let min_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .min_by_float(Product::price_r())
        .unwrap_or(0.0);

    let max_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .max_by_float(Product::price_r())
        .unwrap_or(0.0);

    println!("  Price range for active products:");
    println!("    Min: ${:.2}", min_price);
    println!("    Max: ${:.2}", max_price);

    // ============================================================================
    // LAZY OPERATION 11: find - Find with Predicate
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 11: find (with predicate)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let high_rated = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .find(|item| item.rating > 4.7);

    if let Some(product) = high_rated {
        println!("  First highly-rated electronic:");
        println!("    {}: Rating {:.1}", product.name, product.rating);
    }

    // ============================================================================
    // LAZY OPERATION 12: for_each - Iteration
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 12: for_each (iteration)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  Low stock alerts:");
    LazyQuery::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .for_each(|product| {
            println!("    ⚠️  {}: Only {} in stock", product.name, product.stock);
        });

    // ============================================================================
    // LAZY OPERATION 13: fold - Custom Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 14: fold (custom aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_inventory_value = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .fold(0.0, |acc, product| {
            acc + (product.price * product.stock as f64)
        });

    println!("  Total inventory value: ${:.2}", total_inventory_value);

    // ============================================================================
    // LAZY OPERATION 14: all_match - Validation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 15: all_match (validation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let all_priced = LazyQuery::new(&products)
        .all_match(|item| item.price > 0.0);

    println!("  All products have valid prices: {}", all_priced);

    // ============================================================================
    // LAZY OPERATION 15: into_iter - For Loop
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 16: into_iter (for loop)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  High-value products (>$300):");
    for product in LazyQuery::new(&products)
        .where_(Product::price_r(), |&p| p > 300.0)
        .take_lazy(5)
    {
        println!("    • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // LAZY OPERATION 16: map_items - Transform
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 17: map_items (transformation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let price_tags: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .map_items(|p| format!("{}: ${:.2}", p.name, p.price))
        .take(5)
        .collect();

    println!("  Electronics price tags:");
    for tag in &price_tags {
        println!("    • {}", tag);
    }

    // ============================================================================
    // COMPLEX EXAMPLE: Multi-Stage Lazy Pipeline
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Multi-stage lazy pipeline");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building complex query:");
    println!("  1. Filter by category (Electronics)");
    println!("  2. Filter by price range ($50-$500)");
    println!("  3. Filter by rating (>4.5)");
    println!("  4. Select names");
    println!("  5. Take first 3");
    println!();

    let results: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p >= 50.0 && p <= 500.0)
        .where_(Product::rating_r(), |&r| r > 4.5)
        .select_lazy(Product::name_r())
        .take(3)
        .collect();

    println!("  Results:");
    for (i, name) in results.iter().enumerate() {
        println!("    {}. {}", i + 1, name);
    }
    println!("  ✅ All operations fused and executed lazily!");

    // ============================================================================
    // THREAD-SAFE UPDATES WITH RWLOCK
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Bonus: Thread-safe updates with RwLock");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Update a product through the Arc<RwLock>
    if let Some(product_arc) = product_map.get("PROD-002") {
        println!("Updating PROD-002 stock...");
        
        // Write lock for mutation
        if let Ok(mut product) = product_arc.write() {
            let old_stock = product.stock;
            product.stock = 25;
            println!("  Stock updated: {} → {}", old_stock, product.stock);
        }
    }

    // Query again to see the update
    let updated_products = extract_products(&product_map);
    let mouse = LazyQuery::new(&updated_products)
        .find(|p| p.id == 2);

    if let Some(product) = mouse {
        println!("  Verified update: {} now has {} in stock", product.name, product.stock);
    }

    // ============================================================================
    // PRACTICAL EXAMPLE: Price Analysis by Category
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Practical Example: Price analysis by category");
    println!("═══════════════════════════════════════════════════════════════\n");

    let categories = vec!["Electronics", "Furniture"];

    for category in categories {
        println!("  {} Statistics:", category);
        
        // Filter products by category first
        let cat_products: Vec<Product> = products.iter()
            .filter(|p| p.category == category)
            .cloned()
            .collect();

        let count = LazyQuery::new(&cat_products).count();
        let total = LazyQuery::new(&cat_products).sum_by(Product::price_r());
        let avg = LazyQuery::new(&cat_products).avg_by(Product::price_r()).unwrap_or(0.0);
        let min = LazyQuery::new(&cat_products).min_by_float(Product::price_r()).unwrap_or(0.0);
        let max = LazyQuery::new(&cat_products).max_by_float(Product::price_r()).unwrap_or(0.0);

        println!("    Count: {}", count);
        println!("    Total: ${:.2}", total);
        println!("    Average: ${:.2}", avg);
        println!("    Range: ${:.2} - ${:.2}\n", min, max);
    }

    // ============================================================================
    // COMBINING WITH HASHMAP OPERATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("HashMap Integration: Query by key patterns");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Filter HashMap by key pattern
    let electronics_keys: Vec<String> = product_map
        .iter()
        .filter(|(_key, value)| {
            // Read the value to check category
            if let Ok(guard) = value.read() {
                guard.category == "Electronics"
            } else {
                false
            }
        })
        .map(|(key, _value)| key.clone())
        .collect();

    println!("  Electronics product IDs:");
    for key in electronics_keys.iter().take(5) {
        println!("    • {}", key);
    }

    // ============================================================================
    // PERFORMANCE DEMONSTRATION
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Performance: Lazy vs Eager comparison");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first product with rating > 4.7 from {} products\n", products.len());

    println!("  Eager approach (hypothetical):");
    println!("    - Filter all {} products", products.len());
    println!("    - Collect filtered results");
    println!("    - Take first item");
    println!("    - Wasted work: Check all items\n");

    println!("  Lazy approach (actual):");
    let _first_rated = LazyQuery::new(&products)
        .where_(Product::rating_r(), |&r| r > 4.7)
        .first();
    println!("    - Starts checking products");
    println!("    - Stops at first match");
    println!("    - ✅ Early termination - checks ~3-5 items only!");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: All Lazy Operations Demonstrated                      ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Lazy Query Operations:");
    println!("   1. ✅ where_ - Lazy filtering");
    println!("   2. ✅ select_lazy - Lazy projection");
    println!("   3. ✅ take_lazy - Early termination");
    println!("   4. ✅ skip_lazy - Pagination");
    println!("   5. ✅ first - Short-circuit search");
    println!("   6. ✅ any - Existence check (short-circuit)");
    println!("   7. ✅ count - Count items");
    println!("   8. ✅ sum_by - Sum aggregation");
    println!("   9. ✅ avg_by - Average aggregation");
    println!("   10. ✅ min_by_float - Minimum value");
    println!("   11. ✅ max_by_float - Maximum value");
    println!("   12. ✅ find - Find with predicate (short-circuit)");
    println!("   13. ✅ for_each - Iteration");
    println!("   14. ✅ fold - Custom aggregation");
    println!("   15. ✅ all_match - Validation (short-circuit)");
    println!("   16. ✅ into_iter - For loop support");
    println!("   17. ✅ map_items - Transformation\n");

    println!("✅ Arc<RwLock<T>> Benefits:");
    println!("   • Thread-safe shared access");
    println!("   • Interior mutability");
    println!("   • Multiple readers, single writer");
    println!("   • Reference counting (Arc)");
    println!("   • Can be queried after extracting data\n");

    println!("✅ HashMap<K, Arc<RwLock<V>>> Benefits:");
    println!("   • Fast key-based lookup");
    println!("   • Thread-safe value access");
    println!("   • Can query all values");
    println!("   • Can filter by key patterns");
    println!("   • Perfect for shared state/caches\n");

    println!("🎯 Use Cases:");
    println!("   • Shared product catalogs");
    println!("   • User session stores");
    println!("   • Configuration caches");
    println!("   • Real-time inventory systems");
    println!("   • Multi-threaded data processing");
    println!("   • Web server state management\n");

    println!("✓ Arc<RwLock<T>> HashMap with all lazy operations demo complete!\n");
}

pub fn any(self) -> bool

Checks if any items match (terminal operation - short-circuits).

Example

let exists = query.any();

Examples found in repository

examples/derive_and_ext.rs (line 161)

fn main() {
    println!("Derive Macros and Extension Traits Example");
    println!("===========================================\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. Using Extension Trait - Direct .query() on Vec");
    println!("   Query: products.query().where_(price > 100).all()");
    
    let query = products
        .query()
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in &expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. Using Extension Trait - Direct .lazy_query() on Vec");
    println!("   Query: products.lazy_query().where_(stock < 10).collect()");
    
    let low_stock: Vec<_> = products
        .lazy_query()
        .where_(Product::stock_r(), |&s| s < 10)
        .collect();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in &low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. Using Extension Trait - Chained Operations");
    println!("   Query: products.lazy_query().where_(category == Electronics).take(2).select(name).collect()");
    
    let names: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(2)
        .select_lazy(Product::name_r())
        .collect();
    
    println!("   First 2 electronics:");
    for name in &names {
        println!("   - {}", name);
    }
    println!();

    println!("4. Using QueryBuilder Derive - Static Methods");
    println!("   Query: Product::query(&products).where_(price > 50).count()");
    
    let query4 = Product::query(&products)
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query4.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("5. Using QueryBuilder Derive - Lazy Static Methods");
    println!("   Query: Product::lazy_query(&products).first()");
    
    if let Some(first) = Product::lazy_query(&products).first() {
        println!("   First product: {} (${:.2})", first.name, first.price);
    }
    println!();

    println!("6. Complex Chain with Extension Trait");
    println!("   Query: products.lazy_query()");
    println!("          .where_(category == Electronics)");
    println!("          .where_(price < 500)");
    println!("          .map(|p| format!(\"{{}} - ${{:.2}}\", p.name, p.price))");
    println!("          .collect()");
    
    let formatted: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .map_items(|p| format!("{} - ${:.2}", p.name, p.price))
        .collect();
    
    println!("   Affordable electronics:");
    for item in &formatted {
        println!("   - {}", item);
    }
    println!();

    println!("7. Aggregation with Extension Trait");
    println!("   Query: products.lazy_query().sum_by(Product::stock())");
    
    let total_stock = products
        .lazy_query()
        .sum_by(Product::stock_r());
    
    println!("   Total stock across all products: {}", total_stock);
    println!();

    println!("8. Find with Extension Trait");
    println!("   Query: products.lazy_query().find(|p| p.name.contains(\"Chair\"))");
    
    if let Some(chair) = products.lazy_query().find(|p| p.name.contains("Chair")) {
        println!("   Found: {} in {}", chair.name, chair.category);
    }
    println!();

    println!("9. Early Termination with Extension Trait");
    println!("   Query: products.lazy_query().where_(price > 1000).any()");
    
    let has_luxury = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p > 1000.0)
        .any();
    
    println!("   Has products over $1000: {}", has_luxury);
    println!();

    println!("10. Slice Extension Trait");
    println!("    Query: (&products[..]).lazy_query().count()");
    
    let slice_count = (&products[..])
        .lazy_query()
        .count();
    
    println!("    Count from slice: {}", slice_count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ Extension trait QueryExt adds .query() and .lazy_query() to containers");
    println!("✓ Derive macro QueryBuilder adds static methods Product::query() and Product::lazy_query()");
    println!("✓ Both approaches provide the same query functionality");
    println!("✓ Extension trait is more ergonomic: products.query() vs Query::new(&products)");
    println!("✓ All iterator optimizations (fusion, early termination) still apply");
}

examples/lazy_evaluation.rs (line 163)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Lazy Query Evaluation Demo                                   ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    let products = create_products();
    println!("Created {} products\n", products.len());

    // ============================================================================
    // DEMO 1: Lazy Execution - Nothing Happens Until .collect()
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 1: Lazy execution - deferred until needed");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Building query (should execute nothing)...");
    let lazy_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            cat == "Electronics"
        });

    let evals_after_build = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Filter evaluations after building query: {}", evals_after_build);
    
    if evals_after_build == 0 {
        println!("  ✅ Confirmed: Query is lazy! Nothing executed yet.\n");
    }

    println!("Collecting results (now it executes)...");
    let results: Vec<_> = lazy_query.collect();

    let evals_after_collect = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Filter evaluations after collecting: {}", evals_after_collect);
    println!("  Results found: {}", results.len());
    println!("  ✅ Query executed exactly once, when needed!\n");

    // ============================================================================
    // DEMO 2: Early Termination - Stops as Soon as Enough Items Found
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 2: Early termination with .take()");
    println!("═══════════════════════════════════════════════════════════════\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);

    println!("Finding first 5 expensive items from 1000 products...");
    let first_5: Vec<_> = LazyQuery::new(&products)
        .where_(Product::price_r(), |p| expensive_check(p))
        .take_lazy(5)
        .collect();

    let ops = EXPENSIVE_OPERATIONS.load(Ordering::SeqCst);
    println!("  Found: {} items", first_5.len());
    println!("  Expensive operations performed: {}", ops);
    println!("  Items NOT checked: {} (stopped early!)", 1000 - ops);
    
    if ops < 1000 {
        println!("  ✅ Early termination worked! Didn't check all 1000 items.\n");
    }

    // ============================================================================
    // DEMO 3: Iterator Fusion - Rust Optimizes Chained Operations
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 3: Iterator fusion - chained operations optimized");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Chaining multiple operations...");
    let chained_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price > 200.0)
        .where_(Product::stock_r(), |&stock| stock > 10)
        .take_lazy(10);

    println!("  Built query with 3 filters + take(10)");
    println!("  ✅ No execution yet - all operations fused into one iterator\n");

    let results: Vec<_> = chained_query.collect();
    println!("  Executed: Found {} items", results.len());
    println!("  ✅ All filters applied in single pass!\n");

    // ============================================================================
    // DEMO 4: Lazy Projection - Only Extract What You Need
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 4: Lazy projection");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .select_lazy(Product::name_r())
        .take(5)  // Only process until we have 5
        .collect();

    println!("  Selected {} names", names.len());
    println!("  ✅ Only evaluated until 5 names found!\n");

    // ============================================================================
    // DEMO 5: Lazy Aggregation - Short-Circuit When Possible
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 5: Short-circuit with .any()");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Checking if ANY electronics exist (1000 items to search)...");
    let exists = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            cat == "Electronics"
        })
        .any();

    let checks = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    println!("  Result: {}", exists);
    println!("  Items checked: {} out of 1000", checks);
    println!("  Items skipped: {} (short-circuited!)", 1000 - checks);
    
    if checks < 1000 {
        println!("  ✅ Short-circuit worked! Stopped as soon as first match found.\n");
    }

    // ============================================================================
    // DEMO 6: Lazy Find - Stops at First Match
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 6: .find() stops at first match");
    println!("═══════════════════════════════════════════════════════════════\n");

    FILTER_EVALUATIONS.store(0, Ordering::SeqCst);

    println!("Finding first product with price > 500...");
    let found = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| {
            FILTER_EVALUATIONS.fetch_add(1, Ordering::SeqCst);
            price > 500.0
        })
        .first();

    let checks = FILTER_EVALUATIONS.load(Ordering::SeqCst);
    if let Some(product) = found {
        println!("  Found: {} (${:.2})", product.name, product.price);
    }
    println!("  Items checked: {} out of 1000", checks);
    println!("  ✅ Stopped immediately after finding first match!\n");

    // ============================================================================
    // DEMO 7: Composition - Build Queries Incrementally
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 7: Composable queries");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building base query...");
    let base_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Created base query (not executed)\n");

    println!("  Adding price filter...");
    let refined_query = base_query
        .where_(Product::price_r(), |&price| price > 100.0);

    println!("  Still not executed...\n");

    println!("  Adding stock filter and limiting...");
    let final_query = refined_query
        .where_(Product::stock_r(), |&stock| stock > 5)
        .take_lazy(10);

    println!("  Still not executed...\n");

    println!("  Executing...");
    let results: Vec<_> = final_query.collect();
    println!("  ✅ Executed once with all filters: Found {} items\n", results.len());

    // ============================================================================
    // DEMO 8: For Loop - Natural Iteration
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 8: Use in for loops");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Iterating over filtered products...");
    let mut count = 0;
    for product in LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
    {
        println!("  • {}: ${:.2}", product.name, product.price);
        count += 1;
    }
    println!("  ✅ Processed {} items lazily\n", count);

    // ============================================================================
    // DEMO 9: Performance Comparison
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 9: Performance benefit demonstration");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first expensive item from 1000 products\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);
    
    println!("Without lazy (hypothetical - check all, then take first):");
    println!("  Would check: 1000 items");
    println!("  Would find: ~300 matching items");
    println!("  Would return: 1 item");
    println!("  Wasted work: 299 items processed unnecessarily\n");

    EXPENSIVE_OPERATIONS.store(0, Ordering::SeqCst);
    
    println!("With lazy evaluation:");
    let _first = LazyQuery::new(&products)
        .where_(Product::price_r(), |p| expensive_check(p))
        .first();

    let ops = EXPENSIVE_OPERATIONS.load(Ordering::SeqCst);
    println!("  Checked: {} items", ops);
    println!("  Found: 1 item");
    println!("  Wasted work: 0 items");
    println!("  ✅ Efficiency gain: {}x faster!", 1000 / ops.max(1));

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Lazy Evaluation Benefits                                     ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Deferred Execution:");
    println!("   • No work until results needed");
    println!("   • Can build complex queries without performance cost\n");

    println!("✅ Early Termination:");
    println!("   • .take(n) stops after n items");
    println!("   • .first() stops after 1 item");
    println!("   • .any() stops after first match");
    println!("   • Massive performance win for large datasets\n");

    println!("✅ Iterator Fusion:");
    println!("   • Multiple filters combined into one pass");
    println!("   • Rust compiler optimizes chained operations");
    println!("   • No intermediate allocations\n");

    println!("✅ Composable:");
    println!("   • Build queries incrementally");
    println!("   • Reuse query fragments");
    println!("   • Clean separation of query building vs execution\n");

    println!("✅ Zero Overhead:");
    println!("   • Compiles to same code as manual loops");
    println!("   • No runtime cost for abstraction");
    println!("   • Pay only for what you use\n");

    println!("✓ Lazy evaluation demo complete!\n");
}

examples/arc_rwlock_hashmap.rs (line 180)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Arc<RwLock<T>> HashMap Lazy Query Demo                         ║");
    println!("║  Thread-safe shared data with lazy evaluation                   ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    let product_map = create_sample_data();
    println!("Created product catalog:");
    println!("  Total products: {}", product_map.len());
    println!("  Keys: {:?}\n", product_map.keys().take(3).collect::<Vec<_>>());

    // Extract products for querying
    let products = extract_products(&product_map);
    println!("Extracted {} products from Arc<RwLock<Product>>\n", products.len());

    // ============================================================================
    // LAZY OPERATION 1: where_ - Lazy Filtering
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 1: where_ (filtering)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building filtered query (nothing executes yet)...");
    let electronics_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::active_r(), |&active| active)
        .where_(Product::stock_r(), |&stock| stock > 20);

    println!("  ✅ Query built (deferred execution)\n");

    println!("Collecting results (executes now)...");
    let electronics: Vec<_> = electronics_query.collect();
    println!("  Found {} electronics in stock", electronics.len());
    for p in &electronics {
        println!("    • {}: {} in stock", p.name, p.stock);
    }

    // ============================================================================
    // LAZY OPERATION 2: select_lazy - Lazy Projection
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 2: select_lazy (projection)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting product names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .select_lazy(Product::name_r())
        .collect();

    println!("  Furniture names ({}):", names.len());
    for name in &names {
        println!("    • {}", name);
    }

    // ============================================================================
    // LAZY OPERATION 3: take_lazy - Early Termination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 3: take_lazy (early termination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting first 3 electronics...");
    let first_3: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
        .collect();

    println!("  First 3 electronics:");
    for (i, p) in first_3.iter().enumerate() {
        println!("    {}. {} - ${:.2}", i + 1, p.name, p.price);
    }
    println!("  ✅ Stopped after finding 3 items!");

    // ============================================================================
    // LAZY OPERATION 4: skip_lazy - Pagination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 4: skip_lazy (pagination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting page 2 (skip 3, take 3)...");
    let page_2: Vec<_> = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .skip_lazy(3)
        .take_lazy(3)
        .collect();

    println!("  Page 2 items:");
    for (i, p) in page_2.iter().enumerate() {
        println!("    {}. {}", i + 4, p.name);
    }

    // ============================================================================
    // LAZY OPERATION 5: first - Short-Circuit Search
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 5: first (short-circuit)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Finding first expensive item (>$1000)...");
    let expensive = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0)
        .first();

    match expensive {
        Some(p) => println!("  Found: {} - ${:.2}", p.name, p.price),
        None => println!("  Not found"),
    }
    println!("  ✅ Stopped at first match!");

    // ============================================================================
    // LAZY OPERATION 6: any - Existence Check
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 6: any (existence check)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Checking if any furniture exists...");
    let has_furniture = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .any();

    println!("  Has furniture: {}", has_furniture);
    println!("  ✅ Stopped immediately after finding first match!");

    // ============================================================================
    // LAZY OPERATION 7: count - Count Matching Items
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 7: count");
    println!("═══════════════════════════════════════════════════════════════\n");

    let electronics_count = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .count();

    println!("  Electronics count: {}", electronics_count);

    // ============================================================================
    // LAZY OPERATION 8: sum_by - Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 8: sum_by (aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_value: f64 = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .sum_by(Product::price_r());

    println!("  Total electronics value: ${:.2}", total_value);

    // ============================================================================
    // LAZY OPERATION 9: avg_by - Average
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 9: avg_by");
    println!("═══════════════════════════════════════════════════════════════\n");

    let avg_price = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .avg_by(Product::price_r())
        .unwrap_or(0.0);

    println!("  Average furniture price: ${:.2}", avg_price);

    // ============================================================================
    // LAZY OPERATION 10: min_by_float / max_by_float
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 10: min_by_float / max_by_float");
    println!("═══════════════════════════════════════════════════════════════\n");

    let min_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .min_by_float(Product::price_r())
        .unwrap_or(0.0);

    let max_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .max_by_float(Product::price_r())
        .unwrap_or(0.0);

    println!("  Price range for active products:");
    println!("    Min: ${:.2}", min_price);
    println!("    Max: ${:.2}", max_price);

    // ============================================================================
    // LAZY OPERATION 11: find - Find with Predicate
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 11: find (with predicate)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let high_rated = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .find(|item| item.rating > 4.7);

    if let Some(product) = high_rated {
        println!("  First highly-rated electronic:");
        println!("    {}: Rating {:.1}", product.name, product.rating);
    }

    // ============================================================================
    // LAZY OPERATION 12: for_each - Iteration
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 12: for_each (iteration)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  Low stock alerts:");
    LazyQuery::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .for_each(|product| {
            println!("    ⚠️  {}: Only {} in stock", product.name, product.stock);
        });

    // ============================================================================
    // LAZY OPERATION 13: fold - Custom Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 14: fold (custom aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_inventory_value = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .fold(0.0, |acc, product| {
            acc + (product.price * product.stock as f64)
        });

    println!("  Total inventory value: ${:.2}", total_inventory_value);

    // ============================================================================
    // LAZY OPERATION 14: all_match - Validation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 15: all_match (validation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let all_priced = LazyQuery::new(&products)
        .all_match(|item| item.price > 0.0);

    println!("  All products have valid prices: {}", all_priced);

    // ============================================================================
    // LAZY OPERATION 15: into_iter - For Loop
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 16: into_iter (for loop)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  High-value products (>$300):");
    for product in LazyQuery::new(&products)
        .where_(Product::price_r(), |&p| p > 300.0)
        .take_lazy(5)
    {
        println!("    • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // LAZY OPERATION 16: map_items - Transform
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 17: map_items (transformation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let price_tags: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .map_items(|p| format!("{}: ${:.2}", p.name, p.price))
        .take(5)
        .collect();

    println!("  Electronics price tags:");
    for tag in &price_tags {
        println!("    • {}", tag);
    }

    // ============================================================================
    // COMPLEX EXAMPLE: Multi-Stage Lazy Pipeline
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Multi-stage lazy pipeline");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building complex query:");
    println!("  1. Filter by category (Electronics)");
    println!("  2. Filter by price range ($50-$500)");
    println!("  3. Filter by rating (>4.5)");
    println!("  4. Select names");
    println!("  5. Take first 3");
    println!();

    let results: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p >= 50.0 && p <= 500.0)
        .where_(Product::rating_r(), |&r| r > 4.5)
        .select_lazy(Product::name_r())
        .take(3)
        .collect();

    println!("  Results:");
    for (i, name) in results.iter().enumerate() {
        println!("    {}. {}", i + 1, name);
    }
    println!("  ✅ All operations fused and executed lazily!");

    // ============================================================================
    // THREAD-SAFE UPDATES WITH RWLOCK
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Bonus: Thread-safe updates with RwLock");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Update a product through the Arc<RwLock>
    if let Some(product_arc) = product_map.get("PROD-002") {
        println!("Updating PROD-002 stock...");
        
        // Write lock for mutation
        if let Ok(mut product) = product_arc.write() {
            let old_stock = product.stock;
            product.stock = 25;
            println!("  Stock updated: {} → {}", old_stock, product.stock);
        }
    }

    // Query again to see the update
    let updated_products = extract_products(&product_map);
    let mouse = LazyQuery::new(&updated_products)
        .find(|p| p.id == 2);

    if let Some(product) = mouse {
        println!("  Verified update: {} now has {} in stock", product.name, product.stock);
    }

    // ============================================================================
    // PRACTICAL EXAMPLE: Price Analysis by Category
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Practical Example: Price analysis by category");
    println!("═══════════════════════════════════════════════════════════════\n");

    let categories = vec!["Electronics", "Furniture"];

    for category in categories {
        println!("  {} Statistics:", category);
        
        // Filter products by category first
        let cat_products: Vec<Product> = products.iter()
            .filter(|p| p.category == category)
            .cloned()
            .collect();

        let count = LazyQuery::new(&cat_products).count();
        let total = LazyQuery::new(&cat_products).sum_by(Product::price_r());
        let avg = LazyQuery::new(&cat_products).avg_by(Product::price_r()).unwrap_or(0.0);
        let min = LazyQuery::new(&cat_products).min_by_float(Product::price_r()).unwrap_or(0.0);
        let max = LazyQuery::new(&cat_products).max_by_float(Product::price_r()).unwrap_or(0.0);

        println!("    Count: {}", count);
        println!("    Total: ${:.2}", total);
        println!("    Average: ${:.2}", avg);
        println!("    Range: ${:.2} - ${:.2}\n", min, max);
    }

    // ============================================================================
    // COMBINING WITH HASHMAP OPERATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("HashMap Integration: Query by key patterns");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Filter HashMap by key pattern
    let electronics_keys: Vec<String> = product_map
        .iter()
        .filter(|(_key, value)| {
            // Read the value to check category
            if let Ok(guard) = value.read() {
                guard.category == "Electronics"
            } else {
                false
            }
        })
        .map(|(key, _value)| key.clone())
        .collect();

    println!("  Electronics product IDs:");
    for key in electronics_keys.iter().take(5) {
        println!("    • {}", key);
    }

    // ============================================================================
    // PERFORMANCE DEMONSTRATION
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Performance: Lazy vs Eager comparison");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first product with rating > 4.7 from {} products\n", products.len());

    println!("  Eager approach (hypothetical):");
    println!("    - Filter all {} products", products.len());
    println!("    - Collect filtered results");
    println!("    - Take first item");
    println!("    - Wasted work: Check all items\n");

    println!("  Lazy approach (actual):");
    let _first_rated = LazyQuery::new(&products)
        .where_(Product::rating_r(), |&r| r > 4.7)
        .first();
    println!("    - Starts checking products");
    println!("    - Stops at first match");
    println!("    - ✅ Early termination - checks ~3-5 items only!");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: All Lazy Operations Demonstrated                      ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Lazy Query Operations:");
    println!("   1. ✅ where_ - Lazy filtering");
    println!("   2. ✅ select_lazy - Lazy projection");
    println!("   3. ✅ take_lazy - Early termination");
    println!("   4. ✅ skip_lazy - Pagination");
    println!("   5. ✅ first - Short-circuit search");
    println!("   6. ✅ any - Existence check (short-circuit)");
    println!("   7. ✅ count - Count items");
    println!("   8. ✅ sum_by - Sum aggregation");
    println!("   9. ✅ avg_by - Average aggregation");
    println!("   10. ✅ min_by_float - Minimum value");
    println!("   11. ✅ max_by_float - Maximum value");
    println!("   12. ✅ find - Find with predicate (short-circuit)");
    println!("   13. ✅ for_each - Iteration");
    println!("   14. ✅ fold - Custom aggregation");
    println!("   15. ✅ all_match - Validation (short-circuit)");
    println!("   16. ✅ into_iter - For loop support");
    println!("   17. ✅ map_items - Transformation\n");

    println!("✅ Arc<RwLock<T>> Benefits:");
    println!("   • Thread-safe shared access");
    println!("   • Interior mutability");
    println!("   • Multiple readers, single writer");
    println!("   • Reference counting (Arc)");
    println!("   • Can be queried after extracting data\n");

    println!("✅ HashMap<K, Arc<RwLock<V>>> Benefits:");
    println!("   • Fast key-based lookup");
    println!("   • Thread-safe value access");
    println!("   • Can query all values");
    println!("   • Can filter by key patterns");
    println!("   • Perfect for shared state/caches\n");

    println!("🎯 Use Cases:");
    println!("   • Shared product catalogs");
    println!("   • User session stores");
    println!("   • Configuration caches");
    println!("   • Real-time inventory systems");
    println!("   • Multi-threaded data processing");
    println!("   • Web server state management\n");

    println!("✓ Arc<RwLock<T>> HashMap with all lazy operations demo complete!\n");
}

pub fn for_each<F>(self, f: F)

where F: FnMut(&'a T),

Executes a function for each item (terminal operation).

Example

query.for_each(|item| println!("{:?}", item));

Examples found in repository

examples/arc_rwlock_hashmap.rs (lines 272-274)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Arc<RwLock<T>> HashMap Lazy Query Demo                         ║");
    println!("║  Thread-safe shared data with lazy evaluation                   ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    let product_map = create_sample_data();
    println!("Created product catalog:");
    println!("  Total products: {}", product_map.len());
    println!("  Keys: {:?}\n", product_map.keys().take(3).collect::<Vec<_>>());

    // Extract products for querying
    let products = extract_products(&product_map);
    println!("Extracted {} products from Arc<RwLock<Product>>\n", products.len());

    // ============================================================================
    // LAZY OPERATION 1: where_ - Lazy Filtering
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 1: where_ (filtering)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building filtered query (nothing executes yet)...");
    let electronics_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::active_r(), |&active| active)
        .where_(Product::stock_r(), |&stock| stock > 20);

    println!("  ✅ Query built (deferred execution)\n");

    println!("Collecting results (executes now)...");
    let electronics: Vec<_> = electronics_query.collect();
    println!("  Found {} electronics in stock", electronics.len());
    for p in &electronics {
        println!("    • {}: {} in stock", p.name, p.stock);
    }

    // ============================================================================
    // LAZY OPERATION 2: select_lazy - Lazy Projection
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 2: select_lazy (projection)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting product names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .select_lazy(Product::name_r())
        .collect();

    println!("  Furniture names ({}):", names.len());
    for name in &names {
        println!("    • {}", name);
    }

    // ============================================================================
    // LAZY OPERATION 3: take_lazy - Early Termination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 3: take_lazy (early termination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting first 3 electronics...");
    let first_3: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
        .collect();

    println!("  First 3 electronics:");
    for (i, p) in first_3.iter().enumerate() {
        println!("    {}. {} - ${:.2}", i + 1, p.name, p.price);
    }
    println!("  ✅ Stopped after finding 3 items!");

    // ============================================================================
    // LAZY OPERATION 4: skip_lazy - Pagination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 4: skip_lazy (pagination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting page 2 (skip 3, take 3)...");
    let page_2: Vec<_> = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .skip_lazy(3)
        .take_lazy(3)
        .collect();

    println!("  Page 2 items:");
    for (i, p) in page_2.iter().enumerate() {
        println!("    {}. {}", i + 4, p.name);
    }

    // ============================================================================
    // LAZY OPERATION 5: first - Short-Circuit Search
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 5: first (short-circuit)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Finding first expensive item (>$1000)...");
    let expensive = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0)
        .first();

    match expensive {
        Some(p) => println!("  Found: {} - ${:.2}", p.name, p.price),
        None => println!("  Not found"),
    }
    println!("  ✅ Stopped at first match!");

    // ============================================================================
    // LAZY OPERATION 6: any - Existence Check
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 6: any (existence check)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Checking if any furniture exists...");
    let has_furniture = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .any();

    println!("  Has furniture: {}", has_furniture);
    println!("  ✅ Stopped immediately after finding first match!");

    // ============================================================================
    // LAZY OPERATION 7: count - Count Matching Items
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 7: count");
    println!("═══════════════════════════════════════════════════════════════\n");

    let electronics_count = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .count();

    println!("  Electronics count: {}", electronics_count);

    // ============================================================================
    // LAZY OPERATION 8: sum_by - Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 8: sum_by (aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_value: f64 = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .sum_by(Product::price_r());

    println!("  Total electronics value: ${:.2}", total_value);

    // ============================================================================
    // LAZY OPERATION 9: avg_by - Average
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 9: avg_by");
    println!("═══════════════════════════════════════════════════════════════\n");

    let avg_price = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .avg_by(Product::price_r())
        .unwrap_or(0.0);

    println!("  Average furniture price: ${:.2}", avg_price);

    // ============================================================================
    // LAZY OPERATION 10: min_by_float / max_by_float
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 10: min_by_float / max_by_float");
    println!("═══════════════════════════════════════════════════════════════\n");

    let min_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .min_by_float(Product::price_r())
        .unwrap_or(0.0);

    let max_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .max_by_float(Product::price_r())
        .unwrap_or(0.0);

    println!("  Price range for active products:");
    println!("    Min: ${:.2}", min_price);
    println!("    Max: ${:.2}", max_price);

    // ============================================================================
    // LAZY OPERATION 11: find - Find with Predicate
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 11: find (with predicate)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let high_rated = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .find(|item| item.rating > 4.7);

    if let Some(product) = high_rated {
        println!("  First highly-rated electronic:");
        println!("    {}: Rating {:.1}", product.name, product.rating);
    }

    // ============================================================================
    // LAZY OPERATION 12: for_each - Iteration
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 12: for_each (iteration)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  Low stock alerts:");
    LazyQuery::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .for_each(|product| {
            println!("    ⚠️  {}: Only {} in stock", product.name, product.stock);
        });

    // ============================================================================
    // LAZY OPERATION 13: fold - Custom Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 14: fold (custom aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_inventory_value = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .fold(0.0, |acc, product| {
            acc + (product.price * product.stock as f64)
        });

    println!("  Total inventory value: ${:.2}", total_inventory_value);

    // ============================================================================
    // LAZY OPERATION 14: all_match - Validation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 15: all_match (validation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let all_priced = LazyQuery::new(&products)
        .all_match(|item| item.price > 0.0);

    println!("  All products have valid prices: {}", all_priced);

    // ============================================================================
    // LAZY OPERATION 15: into_iter - For Loop
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 16: into_iter (for loop)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  High-value products (>$300):");
    for product in LazyQuery::new(&products)
        .where_(Product::price_r(), |&p| p > 300.0)
        .take_lazy(5)
    {
        println!("    • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // LAZY OPERATION 16: map_items - Transform
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 17: map_items (transformation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let price_tags: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .map_items(|p| format!("{}: ${:.2}", p.name, p.price))
        .take(5)
        .collect();

    println!("  Electronics price tags:");
    for tag in &price_tags {
        println!("    • {}", tag);
    }

    // ============================================================================
    // COMPLEX EXAMPLE: Multi-Stage Lazy Pipeline
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Multi-stage lazy pipeline");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building complex query:");
    println!("  1. Filter by category (Electronics)");
    println!("  2. Filter by price range ($50-$500)");
    println!("  3. Filter by rating (>4.5)");
    println!("  4. Select names");
    println!("  5. Take first 3");
    println!();

    let results: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p >= 50.0 && p <= 500.0)
        .where_(Product::rating_r(), |&r| r > 4.5)
        .select_lazy(Product::name_r())
        .take(3)
        .collect();

    println!("  Results:");
    for (i, name) in results.iter().enumerate() {
        println!("    {}. {}", i + 1, name);
    }
    println!("  ✅ All operations fused and executed lazily!");

    // ============================================================================
    // THREAD-SAFE UPDATES WITH RWLOCK
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Bonus: Thread-safe updates with RwLock");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Update a product through the Arc<RwLock>
    if let Some(product_arc) = product_map.get("PROD-002") {
        println!("Updating PROD-002 stock...");
        
        // Write lock for mutation
        if let Ok(mut product) = product_arc.write() {
            let old_stock = product.stock;
            product.stock = 25;
            println!("  Stock updated: {} → {}", old_stock, product.stock);
        }
    }

    // Query again to see the update
    let updated_products = extract_products(&product_map);
    let mouse = LazyQuery::new(&updated_products)
        .find(|p| p.id == 2);

    if let Some(product) = mouse {
        println!("  Verified update: {} now has {} in stock", product.name, product.stock);
    }

    // ============================================================================
    // PRACTICAL EXAMPLE: Price Analysis by Category
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Practical Example: Price analysis by category");
    println!("═══════════════════════════════════════════════════════════════\n");

    let categories = vec!["Electronics", "Furniture"];

    for category in categories {
        println!("  {} Statistics:", category);
        
        // Filter products by category first
        let cat_products: Vec<Product> = products.iter()
            .filter(|p| p.category == category)
            .cloned()
            .collect();

        let count = LazyQuery::new(&cat_products).count();
        let total = LazyQuery::new(&cat_products).sum_by(Product::price_r());
        let avg = LazyQuery::new(&cat_products).avg_by(Product::price_r()).unwrap_or(0.0);
        let min = LazyQuery::new(&cat_products).min_by_float(Product::price_r()).unwrap_or(0.0);
        let max = LazyQuery::new(&cat_products).max_by_float(Product::price_r()).unwrap_or(0.0);

        println!("    Count: {}", count);
        println!("    Total: ${:.2}", total);
        println!("    Average: ${:.2}", avg);
        println!("    Range: ${:.2} - ${:.2}\n", min, max);
    }

    // ============================================================================
    // COMBINING WITH HASHMAP OPERATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("HashMap Integration: Query by key patterns");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Filter HashMap by key pattern
    let electronics_keys: Vec<String> = product_map
        .iter()
        .filter(|(_key, value)| {
            // Read the value to check category
            if let Ok(guard) = value.read() {
                guard.category == "Electronics"
            } else {
                false
            }
        })
        .map(|(key, _value)| key.clone())
        .collect();

    println!("  Electronics product IDs:");
    for key in electronics_keys.iter().take(5) {
        println!("    • {}", key);
    }

    // ============================================================================
    // PERFORMANCE DEMONSTRATION
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Performance: Lazy vs Eager comparison");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first product with rating > 4.7 from {} products\n", products.len());

    println!("  Eager approach (hypothetical):");
    println!("    - Filter all {} products", products.len());
    println!("    - Collect filtered results");
    println!("    - Take first item");
    println!("    - Wasted work: Check all items\n");

    println!("  Lazy approach (actual):");
    let _first_rated = LazyQuery::new(&products)
        .where_(Product::rating_r(), |&r| r > 4.7)
        .first();
    println!("    - Starts checking products");
    println!("    - Stops at first match");
    println!("    - ✅ Early termination - checks ~3-5 items only!");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: All Lazy Operations Demonstrated                      ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Lazy Query Operations:");
    println!("   1. ✅ where_ - Lazy filtering");
    println!("   2. ✅ select_lazy - Lazy projection");
    println!("   3. ✅ take_lazy - Early termination");
    println!("   4. ✅ skip_lazy - Pagination");
    println!("   5. ✅ first - Short-circuit search");
    println!("   6. ✅ any - Existence check (short-circuit)");
    println!("   7. ✅ count - Count items");
    println!("   8. ✅ sum_by - Sum aggregation");
    println!("   9. ✅ avg_by - Average aggregation");
    println!("   10. ✅ min_by_float - Minimum value");
    println!("   11. ✅ max_by_float - Maximum value");
    println!("   12. ✅ find - Find with predicate (short-circuit)");
    println!("   13. ✅ for_each - Iteration");
    println!("   14. ✅ fold - Custom aggregation");
    println!("   15. ✅ all_match - Validation (short-circuit)");
    println!("   16. ✅ into_iter - For loop support");
    println!("   17. ✅ map_items - Transformation\n");

    println!("✅ Arc<RwLock<T>> Benefits:");
    println!("   • Thread-safe shared access");
    println!("   • Interior mutability");
    println!("   • Multiple readers, single writer");
    println!("   • Reference counting (Arc)");
    println!("   • Can be queried after extracting data\n");

    println!("✅ HashMap<K, Arc<RwLock<V>>> Benefits:");
    println!("   • Fast key-based lookup");
    println!("   • Thread-safe value access");
    println!("   • Can query all values");
    println!("   • Can filter by key patterns");
    println!("   • Perfect for shared state/caches\n");

    println!("🎯 Use Cases:");
    println!("   • Shared product catalogs");
    println!("   • User session stores");
    println!("   • Configuration caches");
    println!("   • Real-time inventory systems");
    println!("   • Multi-threaded data processing");
    println!("   • Web server state management\n");

    println!("✓ Arc<RwLock<T>> HashMap with all lazy operations demo complete!\n");
}

pub fn fold<B, F>(self, init: B, f: F) -> B

where F: FnMut(B, &'a T) -> B,

Folds the iterator (terminal operation).

Example

let sum = query.fold(0.0, |acc, item| acc + item.price);

Examples found in repository

examples/arc_rwlock_hashmap.rs (lines 285-287)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Arc<RwLock<T>> HashMap Lazy Query Demo                         ║");
    println!("║  Thread-safe shared data with lazy evaluation                   ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    let product_map = create_sample_data();
    println!("Created product catalog:");
    println!("  Total products: {}", product_map.len());
    println!("  Keys: {:?}\n", product_map.keys().take(3).collect::<Vec<_>>());

    // Extract products for querying
    let products = extract_products(&product_map);
    println!("Extracted {} products from Arc<RwLock<Product>>\n", products.len());

    // ============================================================================
    // LAZY OPERATION 1: where_ - Lazy Filtering
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 1: where_ (filtering)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building filtered query (nothing executes yet)...");
    let electronics_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::active_r(), |&active| active)
        .where_(Product::stock_r(), |&stock| stock > 20);

    println!("  ✅ Query built (deferred execution)\n");

    println!("Collecting results (executes now)...");
    let electronics: Vec<_> = electronics_query.collect();
    println!("  Found {} electronics in stock", electronics.len());
    for p in &electronics {
        println!("    • {}: {} in stock", p.name, p.stock);
    }

    // ============================================================================
    // LAZY OPERATION 2: select_lazy - Lazy Projection
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 2: select_lazy (projection)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting product names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .select_lazy(Product::name_r())
        .collect();

    println!("  Furniture names ({}):", names.len());
    for name in &names {
        println!("    • {}", name);
    }

    // ============================================================================
    // LAZY OPERATION 3: take_lazy - Early Termination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 3: take_lazy (early termination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting first 3 electronics...");
    let first_3: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
        .collect();

    println!("  First 3 electronics:");
    for (i, p) in first_3.iter().enumerate() {
        println!("    {}. {} - ${:.2}", i + 1, p.name, p.price);
    }
    println!("  ✅ Stopped after finding 3 items!");

    // ============================================================================
    // LAZY OPERATION 4: skip_lazy - Pagination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 4: skip_lazy (pagination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting page 2 (skip 3, take 3)...");
    let page_2: Vec<_> = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .skip_lazy(3)
        .take_lazy(3)
        .collect();

    println!("  Page 2 items:");
    for (i, p) in page_2.iter().enumerate() {
        println!("    {}. {}", i + 4, p.name);
    }

    // ============================================================================
    // LAZY OPERATION 5: first - Short-Circuit Search
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 5: first (short-circuit)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Finding first expensive item (>$1000)...");
    let expensive = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0)
        .first();

    match expensive {
        Some(p) => println!("  Found: {} - ${:.2}", p.name, p.price),
        None => println!("  Not found"),
    }
    println!("  ✅ Stopped at first match!");

    // ============================================================================
    // LAZY OPERATION 6: any - Existence Check
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 6: any (existence check)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Checking if any furniture exists...");
    let has_furniture = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .any();

    println!("  Has furniture: {}", has_furniture);
    println!("  ✅ Stopped immediately after finding first match!");

    // ============================================================================
    // LAZY OPERATION 7: count - Count Matching Items
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 7: count");
    println!("═══════════════════════════════════════════════════════════════\n");

    let electronics_count = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .count();

    println!("  Electronics count: {}", electronics_count);

    // ============================================================================
    // LAZY OPERATION 8: sum_by - Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 8: sum_by (aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_value: f64 = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .sum_by(Product::price_r());

    println!("  Total electronics value: ${:.2}", total_value);

    // ============================================================================
    // LAZY OPERATION 9: avg_by - Average
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 9: avg_by");
    println!("═══════════════════════════════════════════════════════════════\n");

    let avg_price = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .avg_by(Product::price_r())
        .unwrap_or(0.0);

    println!("  Average furniture price: ${:.2}", avg_price);

    // ============================================================================
    // LAZY OPERATION 10: min_by_float / max_by_float
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 10: min_by_float / max_by_float");
    println!("═══════════════════════════════════════════════════════════════\n");

    let min_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .min_by_float(Product::price_r())
        .unwrap_or(0.0);

    let max_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .max_by_float(Product::price_r())
        .unwrap_or(0.0);

    println!("  Price range for active products:");
    println!("    Min: ${:.2}", min_price);
    println!("    Max: ${:.2}", max_price);

    // ============================================================================
    // LAZY OPERATION 11: find - Find with Predicate
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 11: find (with predicate)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let high_rated = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .find(|item| item.rating > 4.7);

    if let Some(product) = high_rated {
        println!("  First highly-rated electronic:");
        println!("    {}: Rating {:.1}", product.name, product.rating);
    }

    // ============================================================================
    // LAZY OPERATION 12: for_each - Iteration
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 12: for_each (iteration)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  Low stock alerts:");
    LazyQuery::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .for_each(|product| {
            println!("    ⚠️  {}: Only {} in stock", product.name, product.stock);
        });

    // ============================================================================
    // LAZY OPERATION 13: fold - Custom Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 14: fold (custom aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_inventory_value = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .fold(0.0, |acc, product| {
            acc + (product.price * product.stock as f64)
        });

    println!("  Total inventory value: ${:.2}", total_inventory_value);

    // ============================================================================
    // LAZY OPERATION 14: all_match - Validation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 15: all_match (validation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let all_priced = LazyQuery::new(&products)
        .all_match(|item| item.price > 0.0);

    println!("  All products have valid prices: {}", all_priced);

    // ============================================================================
    // LAZY OPERATION 15: into_iter - For Loop
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 16: into_iter (for loop)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  High-value products (>$300):");
    for product in LazyQuery::new(&products)
        .where_(Product::price_r(), |&p| p > 300.0)
        .take_lazy(5)
    {
        println!("    • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // LAZY OPERATION 16: map_items - Transform
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 17: map_items (transformation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let price_tags: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .map_items(|p| format!("{}: ${:.2}", p.name, p.price))
        .take(5)
        .collect();

    println!("  Electronics price tags:");
    for tag in &price_tags {
        println!("    • {}", tag);
    }

    // ============================================================================
    // COMPLEX EXAMPLE: Multi-Stage Lazy Pipeline
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Multi-stage lazy pipeline");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building complex query:");
    println!("  1. Filter by category (Electronics)");
    println!("  2. Filter by price range ($50-$500)");
    println!("  3. Filter by rating (>4.5)");
    println!("  4. Select names");
    println!("  5. Take first 3");
    println!();

    let results: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p >= 50.0 && p <= 500.0)
        .where_(Product::rating_r(), |&r| r > 4.5)
        .select_lazy(Product::name_r())
        .take(3)
        .collect();

    println!("  Results:");
    for (i, name) in results.iter().enumerate() {
        println!("    {}. {}", i + 1, name);
    }
    println!("  ✅ All operations fused and executed lazily!");

    // ============================================================================
    // THREAD-SAFE UPDATES WITH RWLOCK
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Bonus: Thread-safe updates with RwLock");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Update a product through the Arc<RwLock>
    if let Some(product_arc) = product_map.get("PROD-002") {
        println!("Updating PROD-002 stock...");
        
        // Write lock for mutation
        if let Ok(mut product) = product_arc.write() {
            let old_stock = product.stock;
            product.stock = 25;
            println!("  Stock updated: {} → {}", old_stock, product.stock);
        }
    }

    // Query again to see the update
    let updated_products = extract_products(&product_map);
    let mouse = LazyQuery::new(&updated_products)
        .find(|p| p.id == 2);

    if let Some(product) = mouse {
        println!("  Verified update: {} now has {} in stock", product.name, product.stock);
    }

    // ============================================================================
    // PRACTICAL EXAMPLE: Price Analysis by Category
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Practical Example: Price analysis by category");
    println!("═══════════════════════════════════════════════════════════════\n");

    let categories = vec!["Electronics", "Furniture"];

    for category in categories {
        println!("  {} Statistics:", category);
        
        // Filter products by category first
        let cat_products: Vec<Product> = products.iter()
            .filter(|p| p.category == category)
            .cloned()
            .collect();

        let count = LazyQuery::new(&cat_products).count();
        let total = LazyQuery::new(&cat_products).sum_by(Product::price_r());
        let avg = LazyQuery::new(&cat_products).avg_by(Product::price_r()).unwrap_or(0.0);
        let min = LazyQuery::new(&cat_products).min_by_float(Product::price_r()).unwrap_or(0.0);
        let max = LazyQuery::new(&cat_products).max_by_float(Product::price_r()).unwrap_or(0.0);

        println!("    Count: {}", count);
        println!("    Total: ${:.2}", total);
        println!("    Average: ${:.2}", avg);
        println!("    Range: ${:.2} - ${:.2}\n", min, max);
    }

    // ============================================================================
    // COMBINING WITH HASHMAP OPERATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("HashMap Integration: Query by key patterns");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Filter HashMap by key pattern
    let electronics_keys: Vec<String> = product_map
        .iter()
        .filter(|(_key, value)| {
            // Read the value to check category
            if let Ok(guard) = value.read() {
                guard.category == "Electronics"
            } else {
                false
            }
        })
        .map(|(key, _value)| key.clone())
        .collect();

    println!("  Electronics product IDs:");
    for key in electronics_keys.iter().take(5) {
        println!("    • {}", key);
    }

    // ============================================================================
    // PERFORMANCE DEMONSTRATION
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Performance: Lazy vs Eager comparison");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first product with rating > 4.7 from {} products\n", products.len());

    println!("  Eager approach (hypothetical):");
    println!("    - Filter all {} products", products.len());
    println!("    - Collect filtered results");
    println!("    - Take first item");
    println!("    - Wasted work: Check all items\n");

    println!("  Lazy approach (actual):");
    let _first_rated = LazyQuery::new(&products)
        .where_(Product::rating_r(), |&r| r > 4.7)
        .first();
    println!("    - Starts checking products");
    println!("    - Stops at first match");
    println!("    - ✅ Early termination - checks ~3-5 items only!");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: All Lazy Operations Demonstrated                      ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Lazy Query Operations:");
    println!("   1. ✅ where_ - Lazy filtering");
    println!("   2. ✅ select_lazy - Lazy projection");
    println!("   3. ✅ take_lazy - Early termination");
    println!("   4. ✅ skip_lazy - Pagination");
    println!("   5. ✅ first - Short-circuit search");
    println!("   6. ✅ any - Existence check (short-circuit)");
    println!("   7. ✅ count - Count items");
    println!("   8. ✅ sum_by - Sum aggregation");
    println!("   9. ✅ avg_by - Average aggregation");
    println!("   10. ✅ min_by_float - Minimum value");
    println!("   11. ✅ max_by_float - Maximum value");
    println!("   12. ✅ find - Find with predicate (short-circuit)");
    println!("   13. ✅ for_each - Iteration");
    println!("   14. ✅ fold - Custom aggregation");
    println!("   15. ✅ all_match - Validation (short-circuit)");
    println!("   16. ✅ into_iter - For loop support");
    println!("   17. ✅ map_items - Transformation\n");

    println!("✅ Arc<RwLock<T>> Benefits:");
    println!("   • Thread-safe shared access");
    println!("   • Interior mutability");
    println!("   • Multiple readers, single writer");
    println!("   • Reference counting (Arc)");
    println!("   • Can be queried after extracting data\n");

    println!("✅ HashMap<K, Arc<RwLock<V>>> Benefits:");
    println!("   • Fast key-based lookup");
    println!("   • Thread-safe value access");
    println!("   • Can query all values");
    println!("   • Can filter by key patterns");
    println!("   • Perfect for shared state/caches\n");

    println!("🎯 Use Cases:");
    println!("   • Shared product catalogs");
    println!("   • User session stores");
    println!("   • Configuration caches");
    println!("   • Real-time inventory systems");
    println!("   • Multi-threaded data processing");
    println!("   • Web server state management\n");

    println!("✓ Arc<RwLock<T>> HashMap with all lazy operations demo complete!\n");
}

pub fn find<P>(self, predicate: P) -> Option<&'a T>

where P: FnMut(&&'a T) -> bool,

Finds an item matching a predicate (terminal - short-circuits).

Example

let found = query.find(|item| item.id == 42);

Examples found in repository

examples/derive_and_ext.rs (line 150)

fn main() {
    println!("Derive Macros and Extension Traits Example");
    println!("===========================================\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. Using Extension Trait - Direct .query() on Vec");
    println!("   Query: products.query().where_(price > 100).all()");
    
    let query = products
        .query()
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in &expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. Using Extension Trait - Direct .lazy_query() on Vec");
    println!("   Query: products.lazy_query().where_(stock < 10).collect()");
    
    let low_stock: Vec<_> = products
        .lazy_query()
        .where_(Product::stock_r(), |&s| s < 10)
        .collect();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in &low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. Using Extension Trait - Chained Operations");
    println!("   Query: products.lazy_query().where_(category == Electronics).take(2).select(name).collect()");
    
    let names: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(2)
        .select_lazy(Product::name_r())
        .collect();
    
    println!("   First 2 electronics:");
    for name in &names {
        println!("   - {}", name);
    }
    println!();

    println!("4. Using QueryBuilder Derive - Static Methods");
    println!("   Query: Product::query(&products).where_(price > 50).count()");
    
    let query4 = Product::query(&products)
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query4.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("5. Using QueryBuilder Derive - Lazy Static Methods");
    println!("   Query: Product::lazy_query(&products).first()");
    
    if let Some(first) = Product::lazy_query(&products).first() {
        println!("   First product: {} (${:.2})", first.name, first.price);
    }
    println!();

    println!("6. Complex Chain with Extension Trait");
    println!("   Query: products.lazy_query()");
    println!("          .where_(category == Electronics)");
    println!("          .where_(price < 500)");
    println!("          .map(|p| format!(\"{{}} - ${{:.2}}\", p.name, p.price))");
    println!("          .collect()");
    
    let formatted: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .map_items(|p| format!("{} - ${:.2}", p.name, p.price))
        .collect();
    
    println!("   Affordable electronics:");
    for item in &formatted {
        println!("   - {}", item);
    }
    println!();

    println!("7. Aggregation with Extension Trait");
    println!("   Query: products.lazy_query().sum_by(Product::stock())");
    
    let total_stock = products
        .lazy_query()
        .sum_by(Product::stock_r());
    
    println!("   Total stock across all products: {}", total_stock);
    println!();

    println!("8. Find with Extension Trait");
    println!("   Query: products.lazy_query().find(|p| p.name.contains(\"Chair\"))");
    
    if let Some(chair) = products.lazy_query().find(|p| p.name.contains("Chair")) {
        println!("   Found: {} in {}", chair.name, chair.category);
    }
    println!();

    println!("9. Early Termination with Extension Trait");
    println!("   Query: products.lazy_query().where_(price > 1000).any()");
    
    let has_luxury = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p > 1000.0)
        .any();
    
    println!("   Has products over $1000: {}", has_luxury);
    println!();

    println!("10. Slice Extension Trait");
    println!("    Query: (&products[..]).lazy_query().count()");
    
    let slice_count = (&products[..])
        .lazy_query()
        .count();
    
    println!("    Count from slice: {}", slice_count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ Extension trait QueryExt adds .query() and .lazy_query() to containers");
    println!("✓ Derive macro QueryBuilder adds static methods Product::query() and Product::lazy_query()");
    println!("✓ Both approaches provide the same query functionality");
    println!("✓ Extension trait is more ergonomic: products.query() vs Query::new(&products)");
    println!("✓ All iterator optimizations (fusion, early termination) still apply");
}

examples/arc_rwlock_hashmap.rs (line 255)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Arc<RwLock<T>> HashMap Lazy Query Demo                         ║");
    println!("║  Thread-safe shared data with lazy evaluation                   ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    let product_map = create_sample_data();
    println!("Created product catalog:");
    println!("  Total products: {}", product_map.len());
    println!("  Keys: {:?}\n", product_map.keys().take(3).collect::<Vec<_>>());

    // Extract products for querying
    let products = extract_products(&product_map);
    println!("Extracted {} products from Arc<RwLock<Product>>\n", products.len());

    // ============================================================================
    // LAZY OPERATION 1: where_ - Lazy Filtering
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 1: where_ (filtering)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building filtered query (nothing executes yet)...");
    let electronics_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::active_r(), |&active| active)
        .where_(Product::stock_r(), |&stock| stock > 20);

    println!("  ✅ Query built (deferred execution)\n");

    println!("Collecting results (executes now)...");
    let electronics: Vec<_> = electronics_query.collect();
    println!("  Found {} electronics in stock", electronics.len());
    for p in &electronics {
        println!("    • {}: {} in stock", p.name, p.stock);
    }

    // ============================================================================
    // LAZY OPERATION 2: select_lazy - Lazy Projection
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 2: select_lazy (projection)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting product names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .select_lazy(Product::name_r())
        .collect();

    println!("  Furniture names ({}):", names.len());
    for name in &names {
        println!("    • {}", name);
    }

    // ============================================================================
    // LAZY OPERATION 3: take_lazy - Early Termination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 3: take_lazy (early termination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting first 3 electronics...");
    let first_3: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
        .collect();

    println!("  First 3 electronics:");
    for (i, p) in first_3.iter().enumerate() {
        println!("    {}. {} - ${:.2}", i + 1, p.name, p.price);
    }
    println!("  ✅ Stopped after finding 3 items!");

    // ============================================================================
    // LAZY OPERATION 4: skip_lazy - Pagination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 4: skip_lazy (pagination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting page 2 (skip 3, take 3)...");
    let page_2: Vec<_> = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .skip_lazy(3)
        .take_lazy(3)
        .collect();

    println!("  Page 2 items:");
    for (i, p) in page_2.iter().enumerate() {
        println!("    {}. {}", i + 4, p.name);
    }

    // ============================================================================
    // LAZY OPERATION 5: first - Short-Circuit Search
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 5: first (short-circuit)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Finding first expensive item (>$1000)...");
    let expensive = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0)
        .first();

    match expensive {
        Some(p) => println!("  Found: {} - ${:.2}", p.name, p.price),
        None => println!("  Not found"),
    }
    println!("  ✅ Stopped at first match!");

    // ============================================================================
    // LAZY OPERATION 6: any - Existence Check
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 6: any (existence check)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Checking if any furniture exists...");
    let has_furniture = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .any();

    println!("  Has furniture: {}", has_furniture);
    println!("  ✅ Stopped immediately after finding first match!");

    // ============================================================================
    // LAZY OPERATION 7: count - Count Matching Items
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 7: count");
    println!("═══════════════════════════════════════════════════════════════\n");

    let electronics_count = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .count();

    println!("  Electronics count: {}", electronics_count);

    // ============================================================================
    // LAZY OPERATION 8: sum_by - Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 8: sum_by (aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_value: f64 = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .sum_by(Product::price_r());

    println!("  Total electronics value: ${:.2}", total_value);

    // ============================================================================
    // LAZY OPERATION 9: avg_by - Average
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 9: avg_by");
    println!("═══════════════════════════════════════════════════════════════\n");

    let avg_price = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .avg_by(Product::price_r())
        .unwrap_or(0.0);

    println!("  Average furniture price: ${:.2}", avg_price);

    // ============================================================================
    // LAZY OPERATION 10: min_by_float / max_by_float
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 10: min_by_float / max_by_float");
    println!("═══════════════════════════════════════════════════════════════\n");

    let min_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .min_by_float(Product::price_r())
        .unwrap_or(0.0);

    let max_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .max_by_float(Product::price_r())
        .unwrap_or(0.0);

    println!("  Price range for active products:");
    println!("    Min: ${:.2}", min_price);
    println!("    Max: ${:.2}", max_price);

    // ============================================================================
    // LAZY OPERATION 11: find - Find with Predicate
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 11: find (with predicate)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let high_rated = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .find(|item| item.rating > 4.7);

    if let Some(product) = high_rated {
        println!("  First highly-rated electronic:");
        println!("    {}: Rating {:.1}", product.name, product.rating);
    }

    // ============================================================================
    // LAZY OPERATION 12: for_each - Iteration
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 12: for_each (iteration)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  Low stock alerts:");
    LazyQuery::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .for_each(|product| {
            println!("    ⚠️  {}: Only {} in stock", product.name, product.stock);
        });

    // ============================================================================
    // LAZY OPERATION 13: fold - Custom Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 14: fold (custom aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_inventory_value = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .fold(0.0, |acc, product| {
            acc + (product.price * product.stock as f64)
        });

    println!("  Total inventory value: ${:.2}", total_inventory_value);

    // ============================================================================
    // LAZY OPERATION 14: all_match - Validation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 15: all_match (validation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let all_priced = LazyQuery::new(&products)
        .all_match(|item| item.price > 0.0);

    println!("  All products have valid prices: {}", all_priced);

    // ============================================================================
    // LAZY OPERATION 15: into_iter - For Loop
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 16: into_iter (for loop)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  High-value products (>$300):");
    for product in LazyQuery::new(&products)
        .where_(Product::price_r(), |&p| p > 300.0)
        .take_lazy(5)
    {
        println!("    • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // LAZY OPERATION 16: map_items - Transform
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 17: map_items (transformation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let price_tags: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .map_items(|p| format!("{}: ${:.2}", p.name, p.price))
        .take(5)
        .collect();

    println!("  Electronics price tags:");
    for tag in &price_tags {
        println!("    • {}", tag);
    }

    // ============================================================================
    // COMPLEX EXAMPLE: Multi-Stage Lazy Pipeline
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Multi-stage lazy pipeline");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building complex query:");
    println!("  1. Filter by category (Electronics)");
    println!("  2. Filter by price range ($50-$500)");
    println!("  3. Filter by rating (>4.5)");
    println!("  4. Select names");
    println!("  5. Take first 3");
    println!();

    let results: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p >= 50.0 && p <= 500.0)
        .where_(Product::rating_r(), |&r| r > 4.5)
        .select_lazy(Product::name_r())
        .take(3)
        .collect();

    println!("  Results:");
    for (i, name) in results.iter().enumerate() {
        println!("    {}. {}", i + 1, name);
    }
    println!("  ✅ All operations fused and executed lazily!");

    // ============================================================================
    // THREAD-SAFE UPDATES WITH RWLOCK
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Bonus: Thread-safe updates with RwLock");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Update a product through the Arc<RwLock>
    if let Some(product_arc) = product_map.get("PROD-002") {
        println!("Updating PROD-002 stock...");
        
        // Write lock for mutation
        if let Ok(mut product) = product_arc.write() {
            let old_stock = product.stock;
            product.stock = 25;
            println!("  Stock updated: {} → {}", old_stock, product.stock);
        }
    }

    // Query again to see the update
    let updated_products = extract_products(&product_map);
    let mouse = LazyQuery::new(&updated_products)
        .find(|p| p.id == 2);

    if let Some(product) = mouse {
        println!("  Verified update: {} now has {} in stock", product.name, product.stock);
    }

    // ============================================================================
    // PRACTICAL EXAMPLE: Price Analysis by Category
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Practical Example: Price analysis by category");
    println!("═══════════════════════════════════════════════════════════════\n");

    let categories = vec!["Electronics", "Furniture"];

    for category in categories {
        println!("  {} Statistics:", category);
        
        // Filter products by category first
        let cat_products: Vec<Product> = products.iter()
            .filter(|p| p.category == category)
            .cloned()
            .collect();

        let count = LazyQuery::new(&cat_products).count();
        let total = LazyQuery::new(&cat_products).sum_by(Product::price_r());
        let avg = LazyQuery::new(&cat_products).avg_by(Product::price_r()).unwrap_or(0.0);
        let min = LazyQuery::new(&cat_products).min_by_float(Product::price_r()).unwrap_or(0.0);
        let max = LazyQuery::new(&cat_products).max_by_float(Product::price_r()).unwrap_or(0.0);

        println!("    Count: {}", count);
        println!("    Total: ${:.2}", total);
        println!("    Average: ${:.2}", avg);
        println!("    Range: ${:.2} - ${:.2}\n", min, max);
    }

    // ============================================================================
    // COMBINING WITH HASHMAP OPERATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("HashMap Integration: Query by key patterns");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Filter HashMap by key pattern
    let electronics_keys: Vec<String> = product_map
        .iter()
        .filter(|(_key, value)| {
            // Read the value to check category
            if let Ok(guard) = value.read() {
                guard.category == "Electronics"
            } else {
                false
            }
        })
        .map(|(key, _value)| key.clone())
        .collect();

    println!("  Electronics product IDs:");
    for key in electronics_keys.iter().take(5) {
        println!("    • {}", key);
    }

    // ============================================================================
    // PERFORMANCE DEMONSTRATION
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Performance: Lazy vs Eager comparison");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first product with rating > 4.7 from {} products\n", products.len());

    println!("  Eager approach (hypothetical):");
    println!("    - Filter all {} products", products.len());
    println!("    - Collect filtered results");
    println!("    - Take first item");
    println!("    - Wasted work: Check all items\n");

    println!("  Lazy approach (actual):");
    let _first_rated = LazyQuery::new(&products)
        .where_(Product::rating_r(), |&r| r > 4.7)
        .first();
    println!("    - Starts checking products");
    println!("    - Stops at first match");
    println!("    - ✅ Early termination - checks ~3-5 items only!");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: All Lazy Operations Demonstrated                      ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Lazy Query Operations:");
    println!("   1. ✅ where_ - Lazy filtering");
    println!("   2. ✅ select_lazy - Lazy projection");
    println!("   3. ✅ take_lazy - Early termination");
    println!("   4. ✅ skip_lazy - Pagination");
    println!("   5. ✅ first - Short-circuit search");
    println!("   6. ✅ any - Existence check (short-circuit)");
    println!("   7. ✅ count - Count items");
    println!("   8. ✅ sum_by - Sum aggregation");
    println!("   9. ✅ avg_by - Average aggregation");
    println!("   10. ✅ min_by_float - Minimum value");
    println!("   11. ✅ max_by_float - Maximum value");
    println!("   12. ✅ find - Find with predicate (short-circuit)");
    println!("   13. ✅ for_each - Iteration");
    println!("   14. ✅ fold - Custom aggregation");
    println!("   15. ✅ all_match - Validation (short-circuit)");
    println!("   16. ✅ into_iter - For loop support");
    println!("   17. ✅ map_items - Transformation\n");

    println!("✅ Arc<RwLock<T>> Benefits:");
    println!("   • Thread-safe shared access");
    println!("   • Interior mutability");
    println!("   • Multiple readers, single writer");
    println!("   • Reference counting (Arc)");
    println!("   • Can be queried after extracting data\n");

    println!("✅ HashMap<K, Arc<RwLock<V>>> Benefits:");
    println!("   • Fast key-based lookup");
    println!("   • Thread-safe value access");
    println!("   • Can query all values");
    println!("   • Can filter by key patterns");
    println!("   • Perfect for shared state/caches\n");

    println!("🎯 Use Cases:");
    println!("   • Shared product catalogs");
    println!("   • User session stores");
    println!("   • Configuration caches");
    println!("   • Real-time inventory systems");
    println!("   • Multi-threaded data processing");
    println!("   • Web server state management\n");

    println!("✓ Arc<RwLock<T>> HashMap with all lazy operations demo complete!\n");
}

pub fn all_match<P>(self, predicate: P) -> bool

where P: FnMut(&'a T) -> bool,

Checks if all items match a predicate (terminal - short-circuits).

Example

let all_positive = query.all_match(|item| item.value > 0);

Examples found in repository

examples/arc_rwlock_hashmap.rs (line 299)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Arc<RwLock<T>> HashMap Lazy Query Demo                         ║");
    println!("║  Thread-safe shared data with lazy evaluation                   ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    let product_map = create_sample_data();
    println!("Created product catalog:");
    println!("  Total products: {}", product_map.len());
    println!("  Keys: {:?}\n", product_map.keys().take(3).collect::<Vec<_>>());

    // Extract products for querying
    let products = extract_products(&product_map);
    println!("Extracted {} products from Arc<RwLock<Product>>\n", products.len());

    // ============================================================================
    // LAZY OPERATION 1: where_ - Lazy Filtering
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 1: where_ (filtering)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building filtered query (nothing executes yet)...");
    let electronics_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::active_r(), |&active| active)
        .where_(Product::stock_r(), |&stock| stock > 20);

    println!("  ✅ Query built (deferred execution)\n");

    println!("Collecting results (executes now)...");
    let electronics: Vec<_> = electronics_query.collect();
    println!("  Found {} electronics in stock", electronics.len());
    for p in &electronics {
        println!("    • {}: {} in stock", p.name, p.stock);
    }

    // ============================================================================
    // LAZY OPERATION 2: select_lazy - Lazy Projection
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 2: select_lazy (projection)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting product names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .select_lazy(Product::name_r())
        .collect();

    println!("  Furniture names ({}):", names.len());
    for name in &names {
        println!("    • {}", name);
    }

    // ============================================================================
    // LAZY OPERATION 3: take_lazy - Early Termination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 3: take_lazy (early termination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting first 3 electronics...");
    let first_3: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
        .collect();

    println!("  First 3 electronics:");
    for (i, p) in first_3.iter().enumerate() {
        println!("    {}. {} - ${:.2}", i + 1, p.name, p.price);
    }
    println!("  ✅ Stopped after finding 3 items!");

    // ============================================================================
    // LAZY OPERATION 4: skip_lazy - Pagination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 4: skip_lazy (pagination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting page 2 (skip 3, take 3)...");
    let page_2: Vec<_> = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .skip_lazy(3)
        .take_lazy(3)
        .collect();

    println!("  Page 2 items:");
    for (i, p) in page_2.iter().enumerate() {
        println!("    {}. {}", i + 4, p.name);
    }

    // ============================================================================
    // LAZY OPERATION 5: first - Short-Circuit Search
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 5: first (short-circuit)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Finding first expensive item (>$1000)...");
    let expensive = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0)
        .first();

    match expensive {
        Some(p) => println!("  Found: {} - ${:.2}", p.name, p.price),
        None => println!("  Not found"),
    }
    println!("  ✅ Stopped at first match!");

    // ============================================================================
    // LAZY OPERATION 6: any - Existence Check
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 6: any (existence check)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Checking if any furniture exists...");
    let has_furniture = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .any();

    println!("  Has furniture: {}", has_furniture);
    println!("  ✅ Stopped immediately after finding first match!");

    // ============================================================================
    // LAZY OPERATION 7: count - Count Matching Items
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 7: count");
    println!("═══════════════════════════════════════════════════════════════\n");

    let electronics_count = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .count();

    println!("  Electronics count: {}", electronics_count);

    // ============================================================================
    // LAZY OPERATION 8: sum_by - Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 8: sum_by (aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_value: f64 = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .sum_by(Product::price_r());

    println!("  Total electronics value: ${:.2}", total_value);

    // ============================================================================
    // LAZY OPERATION 9: avg_by - Average
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 9: avg_by");
    println!("═══════════════════════════════════════════════════════════════\n");

    let avg_price = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .avg_by(Product::price_r())
        .unwrap_or(0.0);

    println!("  Average furniture price: ${:.2}", avg_price);

    // ============================================================================
    // LAZY OPERATION 10: min_by_float / max_by_float
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 10: min_by_float / max_by_float");
    println!("═══════════════════════════════════════════════════════════════\n");

    let min_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .min_by_float(Product::price_r())
        .unwrap_or(0.0);

    let max_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .max_by_float(Product::price_r())
        .unwrap_or(0.0);

    println!("  Price range for active products:");
    println!("    Min: ${:.2}", min_price);
    println!("    Max: ${:.2}", max_price);

    // ============================================================================
    // LAZY OPERATION 11: find - Find with Predicate
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 11: find (with predicate)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let high_rated = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .find(|item| item.rating > 4.7);

    if let Some(product) = high_rated {
        println!("  First highly-rated electronic:");
        println!("    {}: Rating {:.1}", product.name, product.rating);
    }

    // ============================================================================
    // LAZY OPERATION 12: for_each - Iteration
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 12: for_each (iteration)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  Low stock alerts:");
    LazyQuery::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .for_each(|product| {
            println!("    ⚠️  {}: Only {} in stock", product.name, product.stock);
        });

    // ============================================================================
    // LAZY OPERATION 13: fold - Custom Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 14: fold (custom aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_inventory_value = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .fold(0.0, |acc, product| {
            acc + (product.price * product.stock as f64)
        });

    println!("  Total inventory value: ${:.2}", total_inventory_value);

    // ============================================================================
    // LAZY OPERATION 14: all_match - Validation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 15: all_match (validation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let all_priced = LazyQuery::new(&products)
        .all_match(|item| item.price > 0.0);

    println!("  All products have valid prices: {}", all_priced);

    // ============================================================================
    // LAZY OPERATION 15: into_iter - For Loop
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 16: into_iter (for loop)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  High-value products (>$300):");
    for product in LazyQuery::new(&products)
        .where_(Product::price_r(), |&p| p > 300.0)
        .take_lazy(5)
    {
        println!("    • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // LAZY OPERATION 16: map_items - Transform
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 17: map_items (transformation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let price_tags: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .map_items(|p| format!("{}: ${:.2}", p.name, p.price))
        .take(5)
        .collect();

    println!("  Electronics price tags:");
    for tag in &price_tags {
        println!("    • {}", tag);
    }

    // ============================================================================
    // COMPLEX EXAMPLE: Multi-Stage Lazy Pipeline
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Multi-stage lazy pipeline");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building complex query:");
    println!("  1. Filter by category (Electronics)");
    println!("  2. Filter by price range ($50-$500)");
    println!("  3. Filter by rating (>4.5)");
    println!("  4. Select names");
    println!("  5. Take first 3");
    println!();

    let results: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p >= 50.0 && p <= 500.0)
        .where_(Product::rating_r(), |&r| r > 4.5)
        .select_lazy(Product::name_r())
        .take(3)
        .collect();

    println!("  Results:");
    for (i, name) in results.iter().enumerate() {
        println!("    {}. {}", i + 1, name);
    }
    println!("  ✅ All operations fused and executed lazily!");

    // ============================================================================
    // THREAD-SAFE UPDATES WITH RWLOCK
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Bonus: Thread-safe updates with RwLock");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Update a product through the Arc<RwLock>
    if let Some(product_arc) = product_map.get("PROD-002") {
        println!("Updating PROD-002 stock...");
        
        // Write lock for mutation
        if let Ok(mut product) = product_arc.write() {
            let old_stock = product.stock;
            product.stock = 25;
            println!("  Stock updated: {} → {}", old_stock, product.stock);
        }
    }

    // Query again to see the update
    let updated_products = extract_products(&product_map);
    let mouse = LazyQuery::new(&updated_products)
        .find(|p| p.id == 2);

    if let Some(product) = mouse {
        println!("  Verified update: {} now has {} in stock", product.name, product.stock);
    }

    // ============================================================================
    // PRACTICAL EXAMPLE: Price Analysis by Category
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Practical Example: Price analysis by category");
    println!("═══════════════════════════════════════════════════════════════\n");

    let categories = vec!["Electronics", "Furniture"];

    for category in categories {
        println!("  {} Statistics:", category);
        
        // Filter products by category first
        let cat_products: Vec<Product> = products.iter()
            .filter(|p| p.category == category)
            .cloned()
            .collect();

        let count = LazyQuery::new(&cat_products).count();
        let total = LazyQuery::new(&cat_products).sum_by(Product::price_r());
        let avg = LazyQuery::new(&cat_products).avg_by(Product::price_r()).unwrap_or(0.0);
        let min = LazyQuery::new(&cat_products).min_by_float(Product::price_r()).unwrap_or(0.0);
        let max = LazyQuery::new(&cat_products).max_by_float(Product::price_r()).unwrap_or(0.0);

        println!("    Count: {}", count);
        println!("    Total: ${:.2}", total);
        println!("    Average: ${:.2}", avg);
        println!("    Range: ${:.2} - ${:.2}\n", min, max);
    }

    // ============================================================================
    // COMBINING WITH HASHMAP OPERATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("HashMap Integration: Query by key patterns");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Filter HashMap by key pattern
    let electronics_keys: Vec<String> = product_map
        .iter()
        .filter(|(_key, value)| {
            // Read the value to check category
            if let Ok(guard) = value.read() {
                guard.category == "Electronics"
            } else {
                false
            }
        })
        .map(|(key, _value)| key.clone())
        .collect();

    println!("  Electronics product IDs:");
    for key in electronics_keys.iter().take(5) {
        println!("    • {}", key);
    }

    // ============================================================================
    // PERFORMANCE DEMONSTRATION
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Performance: Lazy vs Eager comparison");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first product with rating > 4.7 from {} products\n", products.len());

    println!("  Eager approach (hypothetical):");
    println!("    - Filter all {} products", products.len());
    println!("    - Collect filtered results");
    println!("    - Take first item");
    println!("    - Wasted work: Check all items\n");

    println!("  Lazy approach (actual):");
    let _first_rated = LazyQuery::new(&products)
        .where_(Product::rating_r(), |&r| r > 4.7)
        .first();
    println!("    - Starts checking products");
    println!("    - Stops at first match");
    println!("    - ✅ Early termination - checks ~3-5 items only!");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: All Lazy Operations Demonstrated                      ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Lazy Query Operations:");
    println!("   1. ✅ where_ - Lazy filtering");
    println!("   2. ✅ select_lazy - Lazy projection");
    println!("   3. ✅ take_lazy - Early termination");
    println!("   4. ✅ skip_lazy - Pagination");
    println!("   5. ✅ first - Short-circuit search");
    println!("   6. ✅ any - Existence check (short-circuit)");
    println!("   7. ✅ count - Count items");
    println!("   8. ✅ sum_by - Sum aggregation");
    println!("   9. ✅ avg_by - Average aggregation");
    println!("   10. ✅ min_by_float - Minimum value");
    println!("   11. ✅ max_by_float - Maximum value");
    println!("   12. ✅ find - Find with predicate (short-circuit)");
    println!("   13. ✅ for_each - Iteration");
    println!("   14. ✅ fold - Custom aggregation");
    println!("   15. ✅ all_match - Validation (short-circuit)");
    println!("   16. ✅ into_iter - For loop support");
    println!("   17. ✅ map_items - Transformation\n");

    println!("✅ Arc<RwLock<T>> Benefits:");
    println!("   • Thread-safe shared access");
    println!("   • Interior mutability");
    println!("   • Multiple readers, single writer");
    println!("   • Reference counting (Arc)");
    println!("   • Can be queried after extracting data\n");

    println!("✅ HashMap<K, Arc<RwLock<V>>> Benefits:");
    println!("   • Fast key-based lookup");
    println!("   • Thread-safe value access");
    println!("   • Can query all values");
    println!("   • Can filter by key patterns");
    println!("   • Perfect for shared state/caches\n");

    println!("🎯 Use Cases:");
    println!("   • Shared product catalogs");
    println!("   • User session stores");
    println!("   • Configuration caches");
    println!("   • Real-time inventory systems");
    println!("   • Multi-threaded data processing");
    println!("   • Web server state management\n");

    println!("✓ Arc<RwLock<T>> HashMap with all lazy operations demo complete!\n");
}

pub fn into_iter(self) -> I

Converts to a standard iterator for further chaining.

Example

let custom: Vec<_> = query
    .into_iter()
    .map(|item| item.custom_transform())
    .filter(|x| x.is_valid())
    .collect();

impl<'a, T, I> LazyQuery<'a, T, I>

where T: 'static, I: Iterator<Item = &'a T> + 'a,

pub fn sum_by<F>(self, path: KeyPaths<T, F>) -> F

where F: Clone + Add<Output = F> + Default + 'static, I: 'a,

Computes sum of a field (terminal operation).

Example

let total: f64 = LazyQuery::new(&products)
    .sum_by(Product::price_r());

Examples found in repository

examples/individual_crates.rs (line 116)

fn main() {
    println!("Individual Crates Example");
    println!("=========================\n");
    println!("Using rust-queries-core + rust-queries-derive directly\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. QueryExt from rust_queries_core");
    println!("   products.query().where_(price > 100).all()");
    
    let query = products
        .query()  // From QueryExt trait
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. QueryBuilder from rust_queries_derive");
    println!("   Product::query(&products).where_(stock < 10).all()");
    
    let query2 = Product::query(&products)  // From QueryBuilder derive
        .where_(Product::stock_r(), |&s| s < 10);
    let low_stock = query2.all();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. LazyQuery from rust_queries_core");
    println!("   products.lazy_query().where_(...).collect()");
    
    let electronics: Vec<_> = products
        .lazy_query()  // From QueryExt trait
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .collect();
    
    println!("   Found {} electronics:", electronics.len());
    for product in electronics {
        println!("   - {}", product.name);
    }
    println!();

    println!("4. Aggregations with LazyQuery");
    println!("   products.lazy_query().sum_by(Product::price_r())");
    
    let total_value: f64 = products
        .lazy_query()
        .sum_by(Product::price_r());
    
    println!("   Total inventory value: ${:.2}", total_value);
    println!();

    println!("5. Early termination with lazy queries");
    println!("   products.lazy_query().where_(...).first()");
    
    if let Some(first_cheap) = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p < 50.0)
        .first()
    {
        println!("   First cheap product: {} (${:.2})", first_cheap.name, first_cheap.price);
    }
    println!();

    println!("6. Using Query (eager) from rust_queries_core");
    println!("   Query::new(&products).where_(...).count()");
    
    let query3 = Query::new(&products)  // Traditional approach
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query3.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ rust_queries_core provides: Query, LazyQuery, QueryExt");
    println!("✓ rust_queries_derive provides: #[derive(QueryBuilder)]");
    println!("✓ key_paths_derive provides: #[derive(Keypaths)]");
    println!("✓ All features work with individual crates!");
}

examples/derive_and_ext.rs (line 142)

fn main() {
    println!("Derive Macros and Extension Traits Example");
    println!("===========================================\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. Using Extension Trait - Direct .query() on Vec");
    println!("   Query: products.query().where_(price > 100).all()");
    
    let query = products
        .query()
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in &expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. Using Extension Trait - Direct .lazy_query() on Vec");
    println!("   Query: products.lazy_query().where_(stock < 10).collect()");
    
    let low_stock: Vec<_> = products
        .lazy_query()
        .where_(Product::stock_r(), |&s| s < 10)
        .collect();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in &low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. Using Extension Trait - Chained Operations");
    println!("   Query: products.lazy_query().where_(category == Electronics).take(2).select(name).collect()");
    
    let names: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(2)
        .select_lazy(Product::name_r())
        .collect();
    
    println!("   First 2 electronics:");
    for name in &names {
        println!("   - {}", name);
    }
    println!();

    println!("4. Using QueryBuilder Derive - Static Methods");
    println!("   Query: Product::query(&products).where_(price > 50).count()");
    
    let query4 = Product::query(&products)
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query4.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("5. Using QueryBuilder Derive - Lazy Static Methods");
    println!("   Query: Product::lazy_query(&products).first()");
    
    if let Some(first) = Product::lazy_query(&products).first() {
        println!("   First product: {} (${:.2})", first.name, first.price);
    }
    println!();

    println!("6. Complex Chain with Extension Trait");
    println!("   Query: products.lazy_query()");
    println!("          .where_(category == Electronics)");
    println!("          .where_(price < 500)");
    println!("          .map(|p| format!(\"{{}} - ${{:.2}}\", p.name, p.price))");
    println!("          .collect()");
    
    let formatted: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .map_items(|p| format!("{} - ${:.2}", p.name, p.price))
        .collect();
    
    println!("   Affordable electronics:");
    for item in &formatted {
        println!("   - {}", item);
    }
    println!();

    println!("7. Aggregation with Extension Trait");
    println!("   Query: products.lazy_query().sum_by(Product::stock())");
    
    let total_stock = products
        .lazy_query()
        .sum_by(Product::stock_r());
    
    println!("   Total stock across all products: {}", total_stock);
    println!();

    println!("8. Find with Extension Trait");
    println!("   Query: products.lazy_query().find(|p| p.name.contains(\"Chair\"))");
    
    if let Some(chair) = products.lazy_query().find(|p| p.name.contains("Chair")) {
        println!("   Found: {} in {}", chair.name, chair.category);
    }
    println!();

    println!("9. Early Termination with Extension Trait");
    println!("   Query: products.lazy_query().where_(price > 1000).any()");
    
    let has_luxury = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p > 1000.0)
        .any();
    
    println!("   Has products over $1000: {}", has_luxury);
    println!();

    println!("10. Slice Extension Trait");
    println!("    Query: (&products[..]).lazy_query().count()");
    
    let slice_count = (&products[..])
        .lazy_query()
        .count();
    
    println!("    Count from slice: {}", slice_count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ Extension trait QueryExt adds .query() and .lazy_query() to containers");
    println!("✓ Derive macro QueryBuilder adds static methods Product::query() and Product::lazy_query()");
    println!("✓ Both approaches provide the same query functionality");
    println!("✓ Extension trait is more ergonomic: products.query() vs Query::new(&products)");
    println!("✓ All iterator optimizations (fusion, early termination) still apply");
}

examples/arc_rwlock_hashmap.rs (line 207)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Arc<RwLock<T>> HashMap Lazy Query Demo                         ║");
    println!("║  Thread-safe shared data with lazy evaluation                   ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    let product_map = create_sample_data();
    println!("Created product catalog:");
    println!("  Total products: {}", product_map.len());
    println!("  Keys: {:?}\n", product_map.keys().take(3).collect::<Vec<_>>());

    // Extract products for querying
    let products = extract_products(&product_map);
    println!("Extracted {} products from Arc<RwLock<Product>>\n", products.len());

    // ============================================================================
    // LAZY OPERATION 1: where_ - Lazy Filtering
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 1: where_ (filtering)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building filtered query (nothing executes yet)...");
    let electronics_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::active_r(), |&active| active)
        .where_(Product::stock_r(), |&stock| stock > 20);

    println!("  ✅ Query built (deferred execution)\n");

    println!("Collecting results (executes now)...");
    let electronics: Vec<_> = electronics_query.collect();
    println!("  Found {} electronics in stock", electronics.len());
    for p in &electronics {
        println!("    • {}: {} in stock", p.name, p.stock);
    }

    // ============================================================================
    // LAZY OPERATION 2: select_lazy - Lazy Projection
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 2: select_lazy (projection)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting product names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .select_lazy(Product::name_r())
        .collect();

    println!("  Furniture names ({}):", names.len());
    for name in &names {
        println!("    • {}", name);
    }

    // ============================================================================
    // LAZY OPERATION 3: take_lazy - Early Termination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 3: take_lazy (early termination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting first 3 electronics...");
    let first_3: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
        .collect();

    println!("  First 3 electronics:");
    for (i, p) in first_3.iter().enumerate() {
        println!("    {}. {} - ${:.2}", i + 1, p.name, p.price);
    }
    println!("  ✅ Stopped after finding 3 items!");

    // ============================================================================
    // LAZY OPERATION 4: skip_lazy - Pagination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 4: skip_lazy (pagination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting page 2 (skip 3, take 3)...");
    let page_2: Vec<_> = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .skip_lazy(3)
        .take_lazy(3)
        .collect();

    println!("  Page 2 items:");
    for (i, p) in page_2.iter().enumerate() {
        println!("    {}. {}", i + 4, p.name);
    }

    // ============================================================================
    // LAZY OPERATION 5: first - Short-Circuit Search
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 5: first (short-circuit)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Finding first expensive item (>$1000)...");
    let expensive = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0)
        .first();

    match expensive {
        Some(p) => println!("  Found: {} - ${:.2}", p.name, p.price),
        None => println!("  Not found"),
    }
    println!("  ✅ Stopped at first match!");

    // ============================================================================
    // LAZY OPERATION 6: any - Existence Check
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 6: any (existence check)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Checking if any furniture exists...");
    let has_furniture = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .any();

    println!("  Has furniture: {}", has_furniture);
    println!("  ✅ Stopped immediately after finding first match!");

    // ============================================================================
    // LAZY OPERATION 7: count - Count Matching Items
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 7: count");
    println!("═══════════════════════════════════════════════════════════════\n");

    let electronics_count = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .count();

    println!("  Electronics count: {}", electronics_count);

    // ============================================================================
    // LAZY OPERATION 8: sum_by - Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 8: sum_by (aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_value: f64 = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .sum_by(Product::price_r());

    println!("  Total electronics value: ${:.2}", total_value);

    // ============================================================================
    // LAZY OPERATION 9: avg_by - Average
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 9: avg_by");
    println!("═══════════════════════════════════════════════════════════════\n");

    let avg_price = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .avg_by(Product::price_r())
        .unwrap_or(0.0);

    println!("  Average furniture price: ${:.2}", avg_price);

    // ============================================================================
    // LAZY OPERATION 10: min_by_float / max_by_float
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 10: min_by_float / max_by_float");
    println!("═══════════════════════════════════════════════════════════════\n");

    let min_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .min_by_float(Product::price_r())
        .unwrap_or(0.0);

    let max_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .max_by_float(Product::price_r())
        .unwrap_or(0.0);

    println!("  Price range for active products:");
    println!("    Min: ${:.2}", min_price);
    println!("    Max: ${:.2}", max_price);

    // ============================================================================
    // LAZY OPERATION 11: find - Find with Predicate
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 11: find (with predicate)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let high_rated = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .find(|item| item.rating > 4.7);

    if let Some(product) = high_rated {
        println!("  First highly-rated electronic:");
        println!("    {}: Rating {:.1}", product.name, product.rating);
    }

    // ============================================================================
    // LAZY OPERATION 12: for_each - Iteration
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 12: for_each (iteration)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  Low stock alerts:");
    LazyQuery::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .for_each(|product| {
            println!("    ⚠️  {}: Only {} in stock", product.name, product.stock);
        });

    // ============================================================================
    // LAZY OPERATION 13: fold - Custom Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 14: fold (custom aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_inventory_value = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .fold(0.0, |acc, product| {
            acc + (product.price * product.stock as f64)
        });

    println!("  Total inventory value: ${:.2}", total_inventory_value);

    // ============================================================================
    // LAZY OPERATION 14: all_match - Validation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 15: all_match (validation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let all_priced = LazyQuery::new(&products)
        .all_match(|item| item.price > 0.0);

    println!("  All products have valid prices: {}", all_priced);

    // ============================================================================
    // LAZY OPERATION 15: into_iter - For Loop
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 16: into_iter (for loop)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  High-value products (>$300):");
    for product in LazyQuery::new(&products)
        .where_(Product::price_r(), |&p| p > 300.0)
        .take_lazy(5)
    {
        println!("    • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // LAZY OPERATION 16: map_items - Transform
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 17: map_items (transformation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let price_tags: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .map_items(|p| format!("{}: ${:.2}", p.name, p.price))
        .take(5)
        .collect();

    println!("  Electronics price tags:");
    for tag in &price_tags {
        println!("    • {}", tag);
    }

    // ============================================================================
    // COMPLEX EXAMPLE: Multi-Stage Lazy Pipeline
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Multi-stage lazy pipeline");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building complex query:");
    println!("  1. Filter by category (Electronics)");
    println!("  2. Filter by price range ($50-$500)");
    println!("  3. Filter by rating (>4.5)");
    println!("  4. Select names");
    println!("  5. Take first 3");
    println!();

    let results: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p >= 50.0 && p <= 500.0)
        .where_(Product::rating_r(), |&r| r > 4.5)
        .select_lazy(Product::name_r())
        .take(3)
        .collect();

    println!("  Results:");
    for (i, name) in results.iter().enumerate() {
        println!("    {}. {}", i + 1, name);
    }
    println!("  ✅ All operations fused and executed lazily!");

    // ============================================================================
    // THREAD-SAFE UPDATES WITH RWLOCK
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Bonus: Thread-safe updates with RwLock");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Update a product through the Arc<RwLock>
    if let Some(product_arc) = product_map.get("PROD-002") {
        println!("Updating PROD-002 stock...");
        
        // Write lock for mutation
        if let Ok(mut product) = product_arc.write() {
            let old_stock = product.stock;
            product.stock = 25;
            println!("  Stock updated: {} → {}", old_stock, product.stock);
        }
    }

    // Query again to see the update
    let updated_products = extract_products(&product_map);
    let mouse = LazyQuery::new(&updated_products)
        .find(|p| p.id == 2);

    if let Some(product) = mouse {
        println!("  Verified update: {} now has {} in stock", product.name, product.stock);
    }

    // ============================================================================
    // PRACTICAL EXAMPLE: Price Analysis by Category
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Practical Example: Price analysis by category");
    println!("═══════════════════════════════════════════════════════════════\n");

    let categories = vec!["Electronics", "Furniture"];

    for category in categories {
        println!("  {} Statistics:", category);
        
        // Filter products by category first
        let cat_products: Vec<Product> = products.iter()
            .filter(|p| p.category == category)
            .cloned()
            .collect();

        let count = LazyQuery::new(&cat_products).count();
        let total = LazyQuery::new(&cat_products).sum_by(Product::price_r());
        let avg = LazyQuery::new(&cat_products).avg_by(Product::price_r()).unwrap_or(0.0);
        let min = LazyQuery::new(&cat_products).min_by_float(Product::price_r()).unwrap_or(0.0);
        let max = LazyQuery::new(&cat_products).max_by_float(Product::price_r()).unwrap_or(0.0);

        println!("    Count: {}", count);
        println!("    Total: ${:.2}", total);
        println!("    Average: ${:.2}", avg);
        println!("    Range: ${:.2} - ${:.2}\n", min, max);
    }

    // ============================================================================
    // COMBINING WITH HASHMAP OPERATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("HashMap Integration: Query by key patterns");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Filter HashMap by key pattern
    let electronics_keys: Vec<String> = product_map
        .iter()
        .filter(|(_key, value)| {
            // Read the value to check category
            if let Ok(guard) = value.read() {
                guard.category == "Electronics"
            } else {
                false
            }
        })
        .map(|(key, _value)| key.clone())
        .collect();

    println!("  Electronics product IDs:");
    for key in electronics_keys.iter().take(5) {
        println!("    • {}", key);
    }

    // ============================================================================
    // PERFORMANCE DEMONSTRATION
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Performance: Lazy vs Eager comparison");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first product with rating > 4.7 from {} products\n", products.len());

    println!("  Eager approach (hypothetical):");
    println!("    - Filter all {} products", products.len());
    println!("    - Collect filtered results");
    println!("    - Take first item");
    println!("    - Wasted work: Check all items\n");

    println!("  Lazy approach (actual):");
    let _first_rated = LazyQuery::new(&products)
        .where_(Product::rating_r(), |&r| r > 4.7)
        .first();
    println!("    - Starts checking products");
    println!("    - Stops at first match");
    println!("    - ✅ Early termination - checks ~3-5 items only!");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: All Lazy Operations Demonstrated                      ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Lazy Query Operations:");
    println!("   1. ✅ where_ - Lazy filtering");
    println!("   2. ✅ select_lazy - Lazy projection");
    println!("   3. ✅ take_lazy - Early termination");
    println!("   4. ✅ skip_lazy - Pagination");
    println!("   5. ✅ first - Short-circuit search");
    println!("   6. ✅ any - Existence check (short-circuit)");
    println!("   7. ✅ count - Count items");
    println!("   8. ✅ sum_by - Sum aggregation");
    println!("   9. ✅ avg_by - Average aggregation");
    println!("   10. ✅ min_by_float - Minimum value");
    println!("   11. ✅ max_by_float - Maximum value");
    println!("   12. ✅ find - Find with predicate (short-circuit)");
    println!("   13. ✅ for_each - Iteration");
    println!("   14. ✅ fold - Custom aggregation");
    println!("   15. ✅ all_match - Validation (short-circuit)");
    println!("   16. ✅ into_iter - For loop support");
    println!("   17. ✅ map_items - Transformation\n");

    println!("✅ Arc<RwLock<T>> Benefits:");
    println!("   • Thread-safe shared access");
    println!("   • Interior mutability");
    println!("   • Multiple readers, single writer");
    println!("   • Reference counting (Arc)");
    println!("   • Can be queried after extracting data\n");

    println!("✅ HashMap<K, Arc<RwLock<V>>> Benefits:");
    println!("   • Fast key-based lookup");
    println!("   • Thread-safe value access");
    println!("   • Can query all values");
    println!("   • Can filter by key patterns");
    println!("   • Perfect for shared state/caches\n");

    println!("🎯 Use Cases:");
    println!("   • Shared product catalogs");
    println!("   • User session stores");
    println!("   • Configuration caches");
    println!("   • Real-time inventory systems");
    println!("   • Multi-threaded data processing");
    println!("   • Web server state management\n");

    println!("✓ Arc<RwLock<T>> HashMap with all lazy operations demo complete!\n");
}

pub fn avg_by(self, path: KeyPaths<T, f64>) -> Option<f64>

where I: 'a,

Computes average of a float field (terminal operation).

Example

let avg = LazyQuery::new(&products)
    .avg_by(Product::price_r());

Examples found in repository

examples/arc_rwlock_hashmap.rs (line 220)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Arc<RwLock<T>> HashMap Lazy Query Demo                         ║");
    println!("║  Thread-safe shared data with lazy evaluation                   ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    let product_map = create_sample_data();
    println!("Created product catalog:");
    println!("  Total products: {}", product_map.len());
    println!("  Keys: {:?}\n", product_map.keys().take(3).collect::<Vec<_>>());

    // Extract products for querying
    let products = extract_products(&product_map);
    println!("Extracted {} products from Arc<RwLock<Product>>\n", products.len());

    // ============================================================================
    // LAZY OPERATION 1: where_ - Lazy Filtering
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 1: where_ (filtering)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building filtered query (nothing executes yet)...");
    let electronics_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::active_r(), |&active| active)
        .where_(Product::stock_r(), |&stock| stock > 20);

    println!("  ✅ Query built (deferred execution)\n");

    println!("Collecting results (executes now)...");
    let electronics: Vec<_> = electronics_query.collect();
    println!("  Found {} electronics in stock", electronics.len());
    for p in &electronics {
        println!("    • {}: {} in stock", p.name, p.stock);
    }

    // ============================================================================
    // LAZY OPERATION 2: select_lazy - Lazy Projection
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 2: select_lazy (projection)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting product names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .select_lazy(Product::name_r())
        .collect();

    println!("  Furniture names ({}):", names.len());
    for name in &names {
        println!("    • {}", name);
    }

    // ============================================================================
    // LAZY OPERATION 3: take_lazy - Early Termination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 3: take_lazy (early termination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting first 3 electronics...");
    let first_3: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
        .collect();

    println!("  First 3 electronics:");
    for (i, p) in first_3.iter().enumerate() {
        println!("    {}. {} - ${:.2}", i + 1, p.name, p.price);
    }
    println!("  ✅ Stopped after finding 3 items!");

    // ============================================================================
    // LAZY OPERATION 4: skip_lazy - Pagination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 4: skip_lazy (pagination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting page 2 (skip 3, take 3)...");
    let page_2: Vec<_> = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .skip_lazy(3)
        .take_lazy(3)
        .collect();

    println!("  Page 2 items:");
    for (i, p) in page_2.iter().enumerate() {
        println!("    {}. {}", i + 4, p.name);
    }

    // ============================================================================
    // LAZY OPERATION 5: first - Short-Circuit Search
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 5: first (short-circuit)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Finding first expensive item (>$1000)...");
    let expensive = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0)
        .first();

    match expensive {
        Some(p) => println!("  Found: {} - ${:.2}", p.name, p.price),
        None => println!("  Not found"),
    }
    println!("  ✅ Stopped at first match!");

    // ============================================================================
    // LAZY OPERATION 6: any - Existence Check
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 6: any (existence check)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Checking if any furniture exists...");
    let has_furniture = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .any();

    println!("  Has furniture: {}", has_furniture);
    println!("  ✅ Stopped immediately after finding first match!");

    // ============================================================================
    // LAZY OPERATION 7: count - Count Matching Items
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 7: count");
    println!("═══════════════════════════════════════════════════════════════\n");

    let electronics_count = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .count();

    println!("  Electronics count: {}", electronics_count);

    // ============================================================================
    // LAZY OPERATION 8: sum_by - Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 8: sum_by (aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_value: f64 = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .sum_by(Product::price_r());

    println!("  Total electronics value: ${:.2}", total_value);

    // ============================================================================
    // LAZY OPERATION 9: avg_by - Average
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 9: avg_by");
    println!("═══════════════════════════════════════════════════════════════\n");

    let avg_price = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .avg_by(Product::price_r())
        .unwrap_or(0.0);

    println!("  Average furniture price: ${:.2}", avg_price);

    // ============================================================================
    // LAZY OPERATION 10: min_by_float / max_by_float
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 10: min_by_float / max_by_float");
    println!("═══════════════════════════════════════════════════════════════\n");

    let min_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .min_by_float(Product::price_r())
        .unwrap_or(0.0);

    let max_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .max_by_float(Product::price_r())
        .unwrap_or(0.0);

    println!("  Price range for active products:");
    println!("    Min: ${:.2}", min_price);
    println!("    Max: ${:.2}", max_price);

    // ============================================================================
    // LAZY OPERATION 11: find - Find with Predicate
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 11: find (with predicate)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let high_rated = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .find(|item| item.rating > 4.7);

    if let Some(product) = high_rated {
        println!("  First highly-rated electronic:");
        println!("    {}: Rating {:.1}", product.name, product.rating);
    }

    // ============================================================================
    // LAZY OPERATION 12: for_each - Iteration
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 12: for_each (iteration)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  Low stock alerts:");
    LazyQuery::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .for_each(|product| {
            println!("    ⚠️  {}: Only {} in stock", product.name, product.stock);
        });

    // ============================================================================
    // LAZY OPERATION 13: fold - Custom Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 14: fold (custom aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_inventory_value = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .fold(0.0, |acc, product| {
            acc + (product.price * product.stock as f64)
        });

    println!("  Total inventory value: ${:.2}", total_inventory_value);

    // ============================================================================
    // LAZY OPERATION 14: all_match - Validation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 15: all_match (validation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let all_priced = LazyQuery::new(&products)
        .all_match(|item| item.price > 0.0);

    println!("  All products have valid prices: {}", all_priced);

    // ============================================================================
    // LAZY OPERATION 15: into_iter - For Loop
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 16: into_iter (for loop)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  High-value products (>$300):");
    for product in LazyQuery::new(&products)
        .where_(Product::price_r(), |&p| p > 300.0)
        .take_lazy(5)
    {
        println!("    • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // LAZY OPERATION 16: map_items - Transform
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 17: map_items (transformation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let price_tags: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .map_items(|p| format!("{}: ${:.2}", p.name, p.price))
        .take(5)
        .collect();

    println!("  Electronics price tags:");
    for tag in &price_tags {
        println!("    • {}", tag);
    }

    // ============================================================================
    // COMPLEX EXAMPLE: Multi-Stage Lazy Pipeline
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Multi-stage lazy pipeline");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building complex query:");
    println!("  1. Filter by category (Electronics)");
    println!("  2. Filter by price range ($50-$500)");
    println!("  3. Filter by rating (>4.5)");
    println!("  4. Select names");
    println!("  5. Take first 3");
    println!();

    let results: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p >= 50.0 && p <= 500.0)
        .where_(Product::rating_r(), |&r| r > 4.5)
        .select_lazy(Product::name_r())
        .take(3)
        .collect();

    println!("  Results:");
    for (i, name) in results.iter().enumerate() {
        println!("    {}. {}", i + 1, name);
    }
    println!("  ✅ All operations fused and executed lazily!");

    // ============================================================================
    // THREAD-SAFE UPDATES WITH RWLOCK
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Bonus: Thread-safe updates with RwLock");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Update a product through the Arc<RwLock>
    if let Some(product_arc) = product_map.get("PROD-002") {
        println!("Updating PROD-002 stock...");
        
        // Write lock for mutation
        if let Ok(mut product) = product_arc.write() {
            let old_stock = product.stock;
            product.stock = 25;
            println!("  Stock updated: {} → {}", old_stock, product.stock);
        }
    }

    // Query again to see the update
    let updated_products = extract_products(&product_map);
    let mouse = LazyQuery::new(&updated_products)
        .find(|p| p.id == 2);

    if let Some(product) = mouse {
        println!("  Verified update: {} now has {} in stock", product.name, product.stock);
    }

    // ============================================================================
    // PRACTICAL EXAMPLE: Price Analysis by Category
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Practical Example: Price analysis by category");
    println!("═══════════════════════════════════════════════════════════════\n");

    let categories = vec!["Electronics", "Furniture"];

    for category in categories {
        println!("  {} Statistics:", category);
        
        // Filter products by category first
        let cat_products: Vec<Product> = products.iter()
            .filter(|p| p.category == category)
            .cloned()
            .collect();

        let count = LazyQuery::new(&cat_products).count();
        let total = LazyQuery::new(&cat_products).sum_by(Product::price_r());
        let avg = LazyQuery::new(&cat_products).avg_by(Product::price_r()).unwrap_or(0.0);
        let min = LazyQuery::new(&cat_products).min_by_float(Product::price_r()).unwrap_or(0.0);
        let max = LazyQuery::new(&cat_products).max_by_float(Product::price_r()).unwrap_or(0.0);

        println!("    Count: {}", count);
        println!("    Total: ${:.2}", total);
        println!("    Average: ${:.2}", avg);
        println!("    Range: ${:.2} - ${:.2}\n", min, max);
    }

    // ============================================================================
    // COMBINING WITH HASHMAP OPERATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("HashMap Integration: Query by key patterns");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Filter HashMap by key pattern
    let electronics_keys: Vec<String> = product_map
        .iter()
        .filter(|(_key, value)| {
            // Read the value to check category
            if let Ok(guard) = value.read() {
                guard.category == "Electronics"
            } else {
                false
            }
        })
        .map(|(key, _value)| key.clone())
        .collect();

    println!("  Electronics product IDs:");
    for key in electronics_keys.iter().take(5) {
        println!("    • {}", key);
    }

    // ============================================================================
    // PERFORMANCE DEMONSTRATION
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Performance: Lazy vs Eager comparison");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first product with rating > 4.7 from {} products\n", products.len());

    println!("  Eager approach (hypothetical):");
    println!("    - Filter all {} products", products.len());
    println!("    - Collect filtered results");
    println!("    - Take first item");
    println!("    - Wasted work: Check all items\n");

    println!("  Lazy approach (actual):");
    let _first_rated = LazyQuery::new(&products)
        .where_(Product::rating_r(), |&r| r > 4.7)
        .first();
    println!("    - Starts checking products");
    println!("    - Stops at first match");
    println!("    - ✅ Early termination - checks ~3-5 items only!");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: All Lazy Operations Demonstrated                      ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Lazy Query Operations:");
    println!("   1. ✅ where_ - Lazy filtering");
    println!("   2. ✅ select_lazy - Lazy projection");
    println!("   3. ✅ take_lazy - Early termination");
    println!("   4. ✅ skip_lazy - Pagination");
    println!("   5. ✅ first - Short-circuit search");
    println!("   6. ✅ any - Existence check (short-circuit)");
    println!("   7. ✅ count - Count items");
    println!("   8. ✅ sum_by - Sum aggregation");
    println!("   9. ✅ avg_by - Average aggregation");
    println!("   10. ✅ min_by_float - Minimum value");
    println!("   11. ✅ max_by_float - Maximum value");
    println!("   12. ✅ find - Find with predicate (short-circuit)");
    println!("   13. ✅ for_each - Iteration");
    println!("   14. ✅ fold - Custom aggregation");
    println!("   15. ✅ all_match - Validation (short-circuit)");
    println!("   16. ✅ into_iter - For loop support");
    println!("   17. ✅ map_items - Transformation\n");

    println!("✅ Arc<RwLock<T>> Benefits:");
    println!("   • Thread-safe shared access");
    println!("   • Interior mutability");
    println!("   • Multiple readers, single writer");
    println!("   • Reference counting (Arc)");
    println!("   • Can be queried after extracting data\n");

    println!("✅ HashMap<K, Arc<RwLock<V>>> Benefits:");
    println!("   • Fast key-based lookup");
    println!("   • Thread-safe value access");
    println!("   • Can query all values");
    println!("   • Can filter by key patterns");
    println!("   • Perfect for shared state/caches\n");

    println!("🎯 Use Cases:");
    println!("   • Shared product catalogs");
    println!("   • User session stores");
    println!("   • Configuration caches");
    println!("   • Real-time inventory systems");
    println!("   • Multi-threaded data processing");
    println!("   • Web server state management\n");

    println!("✓ Arc<RwLock<T>> HashMap with all lazy operations demo complete!\n");
}

pub fn min_by<F>(self, path: KeyPaths<T, F>) -> Option<F>

where F: Ord + Clone + 'static, I: 'a,

Finds minimum value of a field (terminal operation).

Example

let min = LazyQuery::new(&products)
    .min_by(Product::price_r());

pub fn max_by<F>(self, path: KeyPaths<T, F>) -> Option<F>

where F: Ord + Clone + 'static, I: 'a,

Finds maximum value of a field (terminal operation).

Example

let max = LazyQuery::new(&products)
    .max_by(Product::price_r());

pub fn min_by_float(self, path: KeyPaths<T, f64>) -> Option<f64>

where I: 'a,

Finds minimum float value (terminal operation).

Examples found in repository

examples/arc_rwlock_hashmap.rs (line 234)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Arc<RwLock<T>> HashMap Lazy Query Demo                         ║");
    println!("║  Thread-safe shared data with lazy evaluation                   ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    let product_map = create_sample_data();
    println!("Created product catalog:");
    println!("  Total products: {}", product_map.len());
    println!("  Keys: {:?}\n", product_map.keys().take(3).collect::<Vec<_>>());

    // Extract products for querying
    let products = extract_products(&product_map);
    println!("Extracted {} products from Arc<RwLock<Product>>\n", products.len());

    // ============================================================================
    // LAZY OPERATION 1: where_ - Lazy Filtering
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 1: where_ (filtering)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building filtered query (nothing executes yet)...");
    let electronics_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::active_r(), |&active| active)
        .where_(Product::stock_r(), |&stock| stock > 20);

    println!("  ✅ Query built (deferred execution)\n");

    println!("Collecting results (executes now)...");
    let electronics: Vec<_> = electronics_query.collect();
    println!("  Found {} electronics in stock", electronics.len());
    for p in &electronics {
        println!("    • {}: {} in stock", p.name, p.stock);
    }

    // ============================================================================
    // LAZY OPERATION 2: select_lazy - Lazy Projection
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 2: select_lazy (projection)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting product names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .select_lazy(Product::name_r())
        .collect();

    println!("  Furniture names ({}):", names.len());
    for name in &names {
        println!("    • {}", name);
    }

    // ============================================================================
    // LAZY OPERATION 3: take_lazy - Early Termination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 3: take_lazy (early termination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting first 3 electronics...");
    let first_3: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
        .collect();

    println!("  First 3 electronics:");
    for (i, p) in first_3.iter().enumerate() {
        println!("    {}. {} - ${:.2}", i + 1, p.name, p.price);
    }
    println!("  ✅ Stopped after finding 3 items!");

    // ============================================================================
    // LAZY OPERATION 4: skip_lazy - Pagination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 4: skip_lazy (pagination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting page 2 (skip 3, take 3)...");
    let page_2: Vec<_> = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .skip_lazy(3)
        .take_lazy(3)
        .collect();

    println!("  Page 2 items:");
    for (i, p) in page_2.iter().enumerate() {
        println!("    {}. {}", i + 4, p.name);
    }

    // ============================================================================
    // LAZY OPERATION 5: first - Short-Circuit Search
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 5: first (short-circuit)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Finding first expensive item (>$1000)...");
    let expensive = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0)
        .first();

    match expensive {
        Some(p) => println!("  Found: {} - ${:.2}", p.name, p.price),
        None => println!("  Not found"),
    }
    println!("  ✅ Stopped at first match!");

    // ============================================================================
    // LAZY OPERATION 6: any - Existence Check
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 6: any (existence check)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Checking if any furniture exists...");
    let has_furniture = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .any();

    println!("  Has furniture: {}", has_furniture);
    println!("  ✅ Stopped immediately after finding first match!");

    // ============================================================================
    // LAZY OPERATION 7: count - Count Matching Items
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 7: count");
    println!("═══════════════════════════════════════════════════════════════\n");

    let electronics_count = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .count();

    println!("  Electronics count: {}", electronics_count);

    // ============================================================================
    // LAZY OPERATION 8: sum_by - Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 8: sum_by (aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_value: f64 = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .sum_by(Product::price_r());

    println!("  Total electronics value: ${:.2}", total_value);

    // ============================================================================
    // LAZY OPERATION 9: avg_by - Average
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 9: avg_by");
    println!("═══════════════════════════════════════════════════════════════\n");

    let avg_price = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .avg_by(Product::price_r())
        .unwrap_or(0.0);

    println!("  Average furniture price: ${:.2}", avg_price);

    // ============================================================================
    // LAZY OPERATION 10: min_by_float / max_by_float
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 10: min_by_float / max_by_float");
    println!("═══════════════════════════════════════════════════════════════\n");

    let min_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .min_by_float(Product::price_r())
        .unwrap_or(0.0);

    let max_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .max_by_float(Product::price_r())
        .unwrap_or(0.0);

    println!("  Price range for active products:");
    println!("    Min: ${:.2}", min_price);
    println!("    Max: ${:.2}", max_price);

    // ============================================================================
    // LAZY OPERATION 11: find - Find with Predicate
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 11: find (with predicate)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let high_rated = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .find(|item| item.rating > 4.7);

    if let Some(product) = high_rated {
        println!("  First highly-rated electronic:");
        println!("    {}: Rating {:.1}", product.name, product.rating);
    }

    // ============================================================================
    // LAZY OPERATION 12: for_each - Iteration
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 12: for_each (iteration)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  Low stock alerts:");
    LazyQuery::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .for_each(|product| {
            println!("    ⚠️  {}: Only {} in stock", product.name, product.stock);
        });

    // ============================================================================
    // LAZY OPERATION 13: fold - Custom Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 14: fold (custom aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_inventory_value = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .fold(0.0, |acc, product| {
            acc + (product.price * product.stock as f64)
        });

    println!("  Total inventory value: ${:.2}", total_inventory_value);

    // ============================================================================
    // LAZY OPERATION 14: all_match - Validation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 15: all_match (validation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let all_priced = LazyQuery::new(&products)
        .all_match(|item| item.price > 0.0);

    println!("  All products have valid prices: {}", all_priced);

    // ============================================================================
    // LAZY OPERATION 15: into_iter - For Loop
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 16: into_iter (for loop)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  High-value products (>$300):");
    for product in LazyQuery::new(&products)
        .where_(Product::price_r(), |&p| p > 300.0)
        .take_lazy(5)
    {
        println!("    • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // LAZY OPERATION 16: map_items - Transform
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 17: map_items (transformation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let price_tags: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .map_items(|p| format!("{}: ${:.2}", p.name, p.price))
        .take(5)
        .collect();

    println!("  Electronics price tags:");
    for tag in &price_tags {
        println!("    • {}", tag);
    }

    // ============================================================================
    // COMPLEX EXAMPLE: Multi-Stage Lazy Pipeline
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Multi-stage lazy pipeline");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building complex query:");
    println!("  1. Filter by category (Electronics)");
    println!("  2. Filter by price range ($50-$500)");
    println!("  3. Filter by rating (>4.5)");
    println!("  4. Select names");
    println!("  5. Take first 3");
    println!();

    let results: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p >= 50.0 && p <= 500.0)
        .where_(Product::rating_r(), |&r| r > 4.5)
        .select_lazy(Product::name_r())
        .take(3)
        .collect();

    println!("  Results:");
    for (i, name) in results.iter().enumerate() {
        println!("    {}. {}", i + 1, name);
    }
    println!("  ✅ All operations fused and executed lazily!");

    // ============================================================================
    // THREAD-SAFE UPDATES WITH RWLOCK
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Bonus: Thread-safe updates with RwLock");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Update a product through the Arc<RwLock>
    if let Some(product_arc) = product_map.get("PROD-002") {
        println!("Updating PROD-002 stock...");
        
        // Write lock for mutation
        if let Ok(mut product) = product_arc.write() {
            let old_stock = product.stock;
            product.stock = 25;
            println!("  Stock updated: {} → {}", old_stock, product.stock);
        }
    }

    // Query again to see the update
    let updated_products = extract_products(&product_map);
    let mouse = LazyQuery::new(&updated_products)
        .find(|p| p.id == 2);

    if let Some(product) = mouse {
        println!("  Verified update: {} now has {} in stock", product.name, product.stock);
    }

    // ============================================================================
    // PRACTICAL EXAMPLE: Price Analysis by Category
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Practical Example: Price analysis by category");
    println!("═══════════════════════════════════════════════════════════════\n");

    let categories = vec!["Electronics", "Furniture"];

    for category in categories {
        println!("  {} Statistics:", category);
        
        // Filter products by category first
        let cat_products: Vec<Product> = products.iter()
            .filter(|p| p.category == category)
            .cloned()
            .collect();

        let count = LazyQuery::new(&cat_products).count();
        let total = LazyQuery::new(&cat_products).sum_by(Product::price_r());
        let avg = LazyQuery::new(&cat_products).avg_by(Product::price_r()).unwrap_or(0.0);
        let min = LazyQuery::new(&cat_products).min_by_float(Product::price_r()).unwrap_or(0.0);
        let max = LazyQuery::new(&cat_products).max_by_float(Product::price_r()).unwrap_or(0.0);

        println!("    Count: {}", count);
        println!("    Total: ${:.2}", total);
        println!("    Average: ${:.2}", avg);
        println!("    Range: ${:.2} - ${:.2}\n", min, max);
    }

    // ============================================================================
    // COMBINING WITH HASHMAP OPERATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("HashMap Integration: Query by key patterns");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Filter HashMap by key pattern
    let electronics_keys: Vec<String> = product_map
        .iter()
        .filter(|(_key, value)| {
            // Read the value to check category
            if let Ok(guard) = value.read() {
                guard.category == "Electronics"
            } else {
                false
            }
        })
        .map(|(key, _value)| key.clone())
        .collect();

    println!("  Electronics product IDs:");
    for key in electronics_keys.iter().take(5) {
        println!("    • {}", key);
    }

    // ============================================================================
    // PERFORMANCE DEMONSTRATION
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Performance: Lazy vs Eager comparison");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first product with rating > 4.7 from {} products\n", products.len());

    println!("  Eager approach (hypothetical):");
    println!("    - Filter all {} products", products.len());
    println!("    - Collect filtered results");
    println!("    - Take first item");
    println!("    - Wasted work: Check all items\n");

    println!("  Lazy approach (actual):");
    let _first_rated = LazyQuery::new(&products)
        .where_(Product::rating_r(), |&r| r > 4.7)
        .first();
    println!("    - Starts checking products");
    println!("    - Stops at first match");
    println!("    - ✅ Early termination - checks ~3-5 items only!");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: All Lazy Operations Demonstrated                      ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Lazy Query Operations:");
    println!("   1. ✅ where_ - Lazy filtering");
    println!("   2. ✅ select_lazy - Lazy projection");
    println!("   3. ✅ take_lazy - Early termination");
    println!("   4. ✅ skip_lazy - Pagination");
    println!("   5. ✅ first - Short-circuit search");
    println!("   6. ✅ any - Existence check (short-circuit)");
    println!("   7. ✅ count - Count items");
    println!("   8. ✅ sum_by - Sum aggregation");
    println!("   9. ✅ avg_by - Average aggregation");
    println!("   10. ✅ min_by_float - Minimum value");
    println!("   11. ✅ max_by_float - Maximum value");
    println!("   12. ✅ find - Find with predicate (short-circuit)");
    println!("   13. ✅ for_each - Iteration");
    println!("   14. ✅ fold - Custom aggregation");
    println!("   15. ✅ all_match - Validation (short-circuit)");
    println!("   16. ✅ into_iter - For loop support");
    println!("   17. ✅ map_items - Transformation\n");

    println!("✅ Arc<RwLock<T>> Benefits:");
    println!("   • Thread-safe shared access");
    println!("   • Interior mutability");
    println!("   • Multiple readers, single writer");
    println!("   • Reference counting (Arc)");
    println!("   • Can be queried after extracting data\n");

    println!("✅ HashMap<K, Arc<RwLock<V>>> Benefits:");
    println!("   • Fast key-based lookup");
    println!("   • Thread-safe value access");
    println!("   • Can query all values");
    println!("   • Can filter by key patterns");
    println!("   • Perfect for shared state/caches\n");

    println!("🎯 Use Cases:");
    println!("   • Shared product catalogs");
    println!("   • User session stores");
    println!("   • Configuration caches");
    println!("   • Real-time inventory systems");
    println!("   • Multi-threaded data processing");
    println!("   • Web server state management\n");

    println!("✓ Arc<RwLock<T>> HashMap with all lazy operations demo complete!\n");
}

pub fn max_by_float(self, path: KeyPaths<T, f64>) -> Option<f64>

where I: 'a,

Finds maximum float value (terminal operation).

Examples found in repository

examples/arc_rwlock_hashmap.rs (line 239)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Arc<RwLock<T>> HashMap Lazy Query Demo                         ║");
    println!("║  Thread-safe shared data with lazy evaluation                   ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    let product_map = create_sample_data();
    println!("Created product catalog:");
    println!("  Total products: {}", product_map.len());
    println!("  Keys: {:?}\n", product_map.keys().take(3).collect::<Vec<_>>());

    // Extract products for querying
    let products = extract_products(&product_map);
    println!("Extracted {} products from Arc<RwLock<Product>>\n", products.len());

    // ============================================================================
    // LAZY OPERATION 1: where_ - Lazy Filtering
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 1: where_ (filtering)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building filtered query (nothing executes yet)...");
    let electronics_query = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::active_r(), |&active| active)
        .where_(Product::stock_r(), |&stock| stock > 20);

    println!("  ✅ Query built (deferred execution)\n");

    println!("Collecting results (executes now)...");
    let electronics: Vec<_> = electronics_query.collect();
    println!("  Found {} electronics in stock", electronics.len());
    for p in &electronics {
        println!("    • {}: {} in stock", p.name, p.stock);
    }

    // ============================================================================
    // LAZY OPERATION 2: select_lazy - Lazy Projection
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 2: select_lazy (projection)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Selecting product names (lazy)...");
    let names: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .select_lazy(Product::name_r())
        .collect();

    println!("  Furniture names ({}):", names.len());
    for name in &names {
        println!("    • {}", name);
    }

    // ============================================================================
    // LAZY OPERATION 3: take_lazy - Early Termination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 3: take_lazy (early termination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting first 3 electronics...");
    let first_3: Vec<_> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(3)
        .collect();

    println!("  First 3 electronics:");
    for (i, p) in first_3.iter().enumerate() {
        println!("    {}. {} - ${:.2}", i + 1, p.name, p.price);
    }
    println!("  ✅ Stopped after finding 3 items!");

    // ============================================================================
    // LAZY OPERATION 4: skip_lazy - Pagination
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 4: skip_lazy (pagination)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Getting page 2 (skip 3, take 3)...");
    let page_2: Vec<_> = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .skip_lazy(3)
        .take_lazy(3)
        .collect();

    println!("  Page 2 items:");
    for (i, p) in page_2.iter().enumerate() {
        println!("    {}. {}", i + 4, p.name);
    }

    // ============================================================================
    // LAZY OPERATION 5: first - Short-Circuit Search
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 5: first (short-circuit)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Finding first expensive item (>$1000)...");
    let expensive = LazyQuery::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0)
        .first();

    match expensive {
        Some(p) => println!("  Found: {} - ${:.2}", p.name, p.price),
        None => println!("  Not found"),
    }
    println!("  ✅ Stopped at first match!");

    // ============================================================================
    // LAZY OPERATION 6: any - Existence Check
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 6: any (existence check)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Checking if any furniture exists...");
    let has_furniture = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .any();

    println!("  Has furniture: {}", has_furniture);
    println!("  ✅ Stopped immediately after finding first match!");

    // ============================================================================
    // LAZY OPERATION 7: count - Count Matching Items
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 7: count");
    println!("═══════════════════════════════════════════════════════════════\n");

    let electronics_count = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .count();

    println!("  Electronics count: {}", electronics_count);

    // ============================================================================
    // LAZY OPERATION 8: sum_by - Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 8: sum_by (aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_value: f64 = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .sum_by(Product::price_r());

    println!("  Total electronics value: ${:.2}", total_value);

    // ============================================================================
    // LAZY OPERATION 9: avg_by - Average
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 9: avg_by");
    println!("═══════════════════════════════════════════════════════════════\n");

    let avg_price = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .avg_by(Product::price_r())
        .unwrap_or(0.0);

    println!("  Average furniture price: ${:.2}", avg_price);

    // ============================================================================
    // LAZY OPERATION 10: min_by_float / max_by_float
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 10: min_by_float / max_by_float");
    println!("═══════════════════════════════════════════════════════════════\n");

    let min_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .min_by_float(Product::price_r())
        .unwrap_or(0.0);

    let max_price = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .max_by_float(Product::price_r())
        .unwrap_or(0.0);

    println!("  Price range for active products:");
    println!("    Min: ${:.2}", min_price);
    println!("    Max: ${:.2}", max_price);

    // ============================================================================
    // LAZY OPERATION 11: find - Find with Predicate
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 11: find (with predicate)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let high_rated = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .find(|item| item.rating > 4.7);

    if let Some(product) = high_rated {
        println!("  First highly-rated electronic:");
        println!("    {}: Rating {:.1}", product.name, product.rating);
    }

    // ============================================================================
    // LAZY OPERATION 12: for_each - Iteration
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 12: for_each (iteration)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  Low stock alerts:");
    LazyQuery::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .for_each(|product| {
            println!("    ⚠️  {}: Only {} in stock", product.name, product.stock);
        });

    // ============================================================================
    // LAZY OPERATION 13: fold - Custom Aggregation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 14: fold (custom aggregation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let total_inventory_value = LazyQuery::new(&products)
        .where_(Product::active_r(), |&active| active)
        .fold(0.0, |acc, product| {
            acc + (product.price * product.stock as f64)
        });

    println!("  Total inventory value: ${:.2}", total_inventory_value);

    // ============================================================================
    // LAZY OPERATION 14: all_match - Validation
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 15: all_match (validation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let all_priced = LazyQuery::new(&products)
        .all_match(|item| item.price > 0.0);

    println!("  All products have valid prices: {}", all_priced);

    // ============================================================================
    // LAZY OPERATION 15: into_iter - For Loop
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 16: into_iter (for loop)");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  High-value products (>$300):");
    for product in LazyQuery::new(&products)
        .where_(Product::price_r(), |&p| p > 300.0)
        .take_lazy(5)
    {
        println!("    • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // LAZY OPERATION 16: map_items - Transform
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Lazy Operation 17: map_items (transformation)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let price_tags: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .map_items(|p| format!("{}: ${:.2}", p.name, p.price))
        .take(5)
        .collect();

    println!("  Electronics price tags:");
    for tag in &price_tags {
        println!("    • {}", tag);
    }

    // ============================================================================
    // COMPLEX EXAMPLE: Multi-Stage Lazy Pipeline
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Complex Example: Multi-stage lazy pipeline");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Building complex query:");
    println!("  1. Filter by category (Electronics)");
    println!("  2. Filter by price range ($50-$500)");
    println!("  3. Filter by rating (>4.5)");
    println!("  4. Select names");
    println!("  5. Take first 3");
    println!();

    let results: Vec<String> = LazyQuery::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p >= 50.0 && p <= 500.0)
        .where_(Product::rating_r(), |&r| r > 4.5)
        .select_lazy(Product::name_r())
        .take(3)
        .collect();

    println!("  Results:");
    for (i, name) in results.iter().enumerate() {
        println!("    {}. {}", i + 1, name);
    }
    println!("  ✅ All operations fused and executed lazily!");

    // ============================================================================
    // THREAD-SAFE UPDATES WITH RWLOCK
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Bonus: Thread-safe updates with RwLock");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Update a product through the Arc<RwLock>
    if let Some(product_arc) = product_map.get("PROD-002") {
        println!("Updating PROD-002 stock...");
        
        // Write lock for mutation
        if let Ok(mut product) = product_arc.write() {
            let old_stock = product.stock;
            product.stock = 25;
            println!("  Stock updated: {} → {}", old_stock, product.stock);
        }
    }

    // Query again to see the update
    let updated_products = extract_products(&product_map);
    let mouse = LazyQuery::new(&updated_products)
        .find(|p| p.id == 2);

    if let Some(product) = mouse {
        println!("  Verified update: {} now has {} in stock", product.name, product.stock);
    }

    // ============================================================================
    // PRACTICAL EXAMPLE: Price Analysis by Category
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Practical Example: Price analysis by category");
    println!("═══════════════════════════════════════════════════════════════\n");

    let categories = vec!["Electronics", "Furniture"];

    for category in categories {
        println!("  {} Statistics:", category);
        
        // Filter products by category first
        let cat_products: Vec<Product> = products.iter()
            .filter(|p| p.category == category)
            .cloned()
            .collect();

        let count = LazyQuery::new(&cat_products).count();
        let total = LazyQuery::new(&cat_products).sum_by(Product::price_r());
        let avg = LazyQuery::new(&cat_products).avg_by(Product::price_r()).unwrap_or(0.0);
        let min = LazyQuery::new(&cat_products).min_by_float(Product::price_r()).unwrap_or(0.0);
        let max = LazyQuery::new(&cat_products).max_by_float(Product::price_r()).unwrap_or(0.0);

        println!("    Count: {}", count);
        println!("    Total: ${:.2}", total);
        println!("    Average: ${:.2}", avg);
        println!("    Range: ${:.2} - ${:.2}\n", min, max);
    }

    // ============================================================================
    // COMBINING WITH HASHMAP OPERATIONS
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("HashMap Integration: Query by key patterns");
    println!("═══════════════════════════════════════════════════════════════\n");

    // Filter HashMap by key pattern
    let electronics_keys: Vec<String> = product_map
        .iter()
        .filter(|(_key, value)| {
            // Read the value to check category
            if let Ok(guard) = value.read() {
                guard.category == "Electronics"
            } else {
                false
            }
        })
        .map(|(key, _value)| key.clone())
        .collect();

    println!("  Electronics product IDs:");
    for key in electronics_keys.iter().take(5) {
        println!("    • {}", key);
    }

    // ============================================================================
    // PERFORMANCE DEMONSTRATION
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Performance: Lazy vs Eager comparison");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("Scenario: Find first product with rating > 4.7 from {} products\n", products.len());

    println!("  Eager approach (hypothetical):");
    println!("    - Filter all {} products", products.len());
    println!("    - Collect filtered results");
    println!("    - Take first item");
    println!("    - Wasted work: Check all items\n");

    println!("  Lazy approach (actual):");
    let _first_rated = LazyQuery::new(&products)
        .where_(Product::rating_r(), |&r| r > 4.7)
        .first();
    println!("    - Starts checking products");
    println!("    - Stops at first match");
    println!("    - ✅ Early termination - checks ~3-5 items only!");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔══════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: All Lazy Operations Demonstrated                      ║");
    println!("╚══════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Lazy Query Operations:");
    println!("   1. ✅ where_ - Lazy filtering");
    println!("   2. ✅ select_lazy - Lazy projection");
    println!("   3. ✅ take_lazy - Early termination");
    println!("   4. ✅ skip_lazy - Pagination");
    println!("   5. ✅ first - Short-circuit search");
    println!("   6. ✅ any - Existence check (short-circuit)");
    println!("   7. ✅ count - Count items");
    println!("   8. ✅ sum_by - Sum aggregation");
    println!("   9. ✅ avg_by - Average aggregation");
    println!("   10. ✅ min_by_float - Minimum value");
    println!("   11. ✅ max_by_float - Maximum value");
    println!("   12. ✅ find - Find with predicate (short-circuit)");
    println!("   13. ✅ for_each - Iteration");
    println!("   14. ✅ fold - Custom aggregation");
    println!("   15. ✅ all_match - Validation (short-circuit)");
    println!("   16. ✅ into_iter - For loop support");
    println!("   17. ✅ map_items - Transformation\n");

    println!("✅ Arc<RwLock<T>> Benefits:");
    println!("   • Thread-safe shared access");
    println!("   • Interior mutability");
    println!("   • Multiple readers, single writer");
    println!("   • Reference counting (Arc)");
    println!("   • Can be queried after extracting data\n");

    println!("✅ HashMap<K, Arc<RwLock<V>>> Benefits:");
    println!("   • Fast key-based lookup");
    println!("   • Thread-safe value access");
    println!("   • Can query all values");
    println!("   • Can filter by key patterns");
    println!("   • Perfect for shared state/caches\n");

    println!("🎯 Use Cases:");
    println!("   • Shared product catalogs");
    println!("   • User session stores");
    println!("   • Configuration caches");
    println!("   • Real-time inventory systems");
    println!("   • Multi-threaded data processing");
    println!("   • Web server state management\n");

    println!("✓ Arc<RwLock<T>> HashMap with all lazy operations demo complete!\n");
}

Trait Implementations

impl<'a, T, I> IntoIterator for LazyQuery<'a, T, I>

where T: 'static, I: Iterator<Item = &'a T>,

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = I

Which kind of iterator are we turning this into?

fn into_iter(self) -> <LazyQuery<'a, T, I> as IntoIterator>::IntoIter

Creates an iterator from a value.