Unified zip operations for mixed STL/Aleph containers. More...

#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <list>
#include <set>
#include <tclap/CmdLine.h>
#include <htlist.H>
#include <tpl_dynArray.H>
#include <ah-zip-utils.H>

Include dependency graph for zip_utils_example.C:

Functions
void	print_section (const string &title)

void	print_subsection (const string &title)

void	demo_mixed_containers ()

void	demo_predicates ()

void	demo_transformations ()

void	demo_utilities ()

void	demo_advanced ()

void	demo_conversion ()

void	demo_practical ()

int	main (int argc, char *argv[])

Detailed Description

Unified zip operations for mixed STL/Aleph containers.

This program demonstrates ah-zip-utils.H which provides zip operations that work seamlessly with both STL and Aleph containers, and even allows mixing them in the same operation. This unified approach eliminates container-specific APIs.

What is Zipping?

Zipping combines multiple containers element-wise:

Container 1: [a, b, c]
Container 2: [1, 2, 3]
Zipped:      [(a,1), (b,2), (c,3)]

Key insight: Process related data from multiple sources together.

Key Feature: Container Interoperability

The Problem

Different zip libraries support different containers:

**ah-zip.H**: Aleph containers only
STL: No built-in zip (C++20 ranges add it)
Different APIs: Hard to mix containers

The Solution

ah-zip-utils.H provides unified zip that:

Works with any container type (STL or Aleph)
Automatically detects container type
Mixes containers in same operation
Uses same API for all

Example: Mixing Containers

std::vector<string> names = {"Alice", "Bob", "Charlie"};
DynList<int> ages;
ages.append(25); ages.append(30); ages.append(35);
 
// Mix STL and Aleph containers!
auto zipped = uni_zip(names, ages);
// Result: [("Alice", 25), ("Bob", 30), ("Charlie", 35)]

Functions Demonstrated

Basic Operations

**uni_zip()**: Create list of tuples from any containers
**uni_zip_it()**: Get unified iterator for zipped containers

Predicates

**uni_zip_all()**: All tuples satisfy predicate?
**uni_zip_exists()**: At least one tuple satisfies?
**uni_zip_none()**: No tuple satisfies?

Transformations

**uni_zip_map()**: Transform tuples (apply function to each tuple)
**uni_zip_filter()**: Keep tuples satisfying predicate
**uni_zip_mapi()**: Transform with index
**uni_zip_filteri()**: Filter with index

Utilities

**uni_zip_take(n)**: Take first n tuples
**uni_zip_drop(n)**: Skip first n tuples
**uni_zip_min()**: Find minimum tuple (by first element)
**uni_zip_max()**: Find maximum tuple
**uni_unzip()**: Split tuples back into separate containers

Use Cases

Data Processing

// Process names and scores together
auto results = uni_zip_map(names, scores,
  [](auto name, auto score) {
    return name + ": " + std::to_string(score);
  });

Parallel Processing

// Process multiple related datasets
uni_zip_for_each(prices, quantities, costs,
  [](auto price, auto qty, auto cost) {
    process_order(price, qty, cost);
  });

Data Validation

// Check if all pairs are valid
if (uni_zip_all(names, emails, is_valid_pair)) {
  process_data();
}

Comparison with Alternatives

Feature	ah-zip.H	STL (C++20)	ah-zip-utils.H
STL support	❌ No	✅ Yes	✅ Yes
Aleph support	✅ Yes	❌ No	✅ Yes
Mix containers	❌ No	❌ No	✅ Yes
Unified API	❌ No	❌ No	✅ Yes

Performance Considerations

Type detection: Minimal overhead (compile-time)
Iterator abstraction: Small overhead for unified interface
Efficiency: Operations are as efficient as underlying containers

Usage

# Run all demonstrations
./zip_utils_example
 
# Run specific demo
./zip_utils_example -s mixed       # Mixed container demo
./zip_utils_example -s predicates  # Predicates on zipped data
./zip_utils_example -s transform   # Transformation demo
./zip_utils_example -s utilities   # Utility helpers
./zip_utils_example -s advanced    # Advanced usage
./zip_utils_example -s conversion  # Conversions and interop
./zip_utils_example -s practical   # Practical examples
 
# Show help
./zip_utils_example --help