ah-stl-zip.H

Go to the documentation of this file.

/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
 
# ifndef AH_STL_ZIP_H
# define AH_STL_ZIP_H
 
# include <type_traits>
# include <tuple>
# include <iterator>
# include <utility>
# include <optional>
# include <functional>
 
 
namespace Aleph
{
  // ============================================================================
  // StlZipIterator - Core iterator for zipping STL containers
  // ============================================================================
 
  namespace stl_zip_detail
  {
    // Check if all iterators are valid (not at end)
    template <typename... IterPairs>
    constexpr bool all_valid(const IterPairs &... its) noexcept
    {
      return (... and (std::get<0>(its) != std::get<1>(its)));
    }
 
    // Advance all iterators
    template <typename... IterPairs>
    constexpr void advance_all(IterPairs &... its) noexcept
    {
      (++std::get<0>(its), ...);
    }
 
    // Dereference all iterators and make a tuple
    template <typename... IterPairs>
    constexpr auto deref_all(const IterPairs &... its)
    {
      return std::tuple<decltype(*std::get<0>(its))...>(*std::get<0>(its)...);
    }
 
    // Get value types from iterator pairs
    template <typename IterPair>
    using iter_value_t = std::decay_t<decltype(*std::get<0>(std::declval<IterPair>()))>;
  } // namespace stl_zip_detail
 
  template <typename... Containers>
  class StlZipIterator
  {
  public:
    // Iterator type aliases for STL compatibility
    using iterator_category = std::input_iterator_tag;
    using difference_type = std::ptrdiff_t;
 
    // Each element is a pair of (current_iterator, end_iterator)
    using IteratorTuple = std::tuple<
      std::pair<typename std::decay_t<Containers>::const_iterator,
                typename std::decay_t<Containers>::const_iterator>...>;
 
    // Value type is a tuple of references to elements
    using value_type = std::tuple<
      typename std::decay_t<Containers>::value_type...>;
 
    using reference = std::tuple<
      const typename std::decay_t<Containers>::value_type &...>;
 
    using pointer = void;
 
  private:
    IteratorTuple iters_;
 
    // Helper to check if all iterators are valid
    template <size_t... Is>
    [[nodiscard]] constexpr bool has_curr_impl(std::index_sequence<Is...>) const noexcept
    {
      return stl_zip_detail::all_valid(std::get<Is>(iters_)...);
    }
 
    // Helper to dereference all iterators
    template <size_t... Is>
    [[nodiscard]] constexpr auto deref_impl(std::index_sequence<Is...>) const
    {
      return stl_zip_detail::deref_all(std::get<Is>(iters_)...);
    }
 
    // Helper to advance all iterators
    template <size_t... Is>
    constexpr void advance_impl(std::index_sequence<Is...>) noexcept
    {
      stl_zip_detail::advance_all(std::get<Is>(iters_)...);
    }
 
    // Helper to check if all iterators completed
    template <size_t... Is>
    [[nodiscard]] constexpr bool completed_impl(std::index_sequence<Is...>) const noexcept
    {
      return (... and (std::get<0>(std::get<Is>(iters_)) ==
                       std::get<1>(std::get<Is>(iters_))));
    }
 
  public:
    static constexpr size_t num_containers = sizeof...(Containers);
 
    explicit constexpr StlZipIterator(const Containers &... cs)
      : iters_(std::make_pair(cs.begin(), cs.end())...) {}
 
    struct end_tag
    {};
 
    constexpr StlZipIterator(const Containers &... cs, end_tag)
      : iters_(std::make_pair(cs.end(), cs.end())...) {}
 
    [[nodiscard]] constexpr bool has_curr() const noexcept
    {
      return has_curr_impl(std::make_index_sequence<num_containers>{});
    }
 
    [[nodiscard]] constexpr bool completed() const noexcept
    {
      return completed_impl(std::make_index_sequence<num_containers>{});
    }
 
    [[nodiscard]] constexpr auto get_curr() const
    {
      return deref_impl(std::make_index_sequence<num_containers>{});
    }
 
    constexpr void next() noexcept
    {
      advance_impl(std::make_index_sequence<num_containers>{});
    }
 
    constexpr void next_ne() noexcept { next(); }
 
    // STL iterator interface
 
    [[nodiscard]] constexpr auto operator*() const
    {
      return get_curr();
    }
 
    constexpr StlZipIterator &operator++() noexcept
    {
      next();
      return *this;
    }
 
    constexpr StlZipIterator operator++(int) noexcept
    {
      auto tmp = *this;
      next();
      return tmp;
    }
 
    [[nodiscard]] constexpr bool operator==(const StlZipIterator & other) const noexcept
    {
      return not has_curr() and not other.has_curr();
    }
 
    [[nodiscard]] constexpr bool operator!=(const StlZipIterator & other) const noexcept
    {
      return not (*this == other);
    }
  };
 
  template <typename... Containers>
  class StlZipView
  {
    std::tuple<const std::decay_t<Containers> &...> containers_;
 
  public:
    using iterator = StlZipIterator<std::decay_t<Containers>...>;
    using const_iterator = iterator;
    using value_type = typename iterator::value_type;
 
    explicit constexpr StlZipView(const Containers &... cs)
      : containers_(cs...) {}
 
    [[nodiscard]] constexpr iterator begin() const
    {
      return std::apply([](const auto &... cs)
                          {
                            return iterator(cs...);
                          }, containers_);
    }
 
    [[nodiscard]] constexpr iterator end() const
    {
      return std::apply([](const auto &... cs)
                          {
                            return iterator(cs..., typename iterator::end_tag{});
                          }, containers_);
    }
 
    [[nodiscard]] constexpr bool empty() const
    {
      return not begin().has_curr();
    }
 
    [[nodiscard]] size_t size() const
    {
      size_t count = 0;
      for (auto it = begin(); it.has_curr(); it.next())
        ++count;
      return count;
    }
  };
 
  // ============================================================================
  // Factory Functions
  // ============================================================================
 
  template <typename... Containers>
  [[nodiscard]] constexpr auto stl_zip(const Containers &... cs)
  {
    static_assert(sizeof...(Containers) >= 2, "stl_zip requires at least 2 containers");
    return StlZipView<Containers...>(cs...);
  }
 
  template <typename... Containers>
  [[nodiscard]] constexpr auto stl_zip_it(const Containers &... cs)
  {
    return StlZipIterator<std::decay_t<Containers>...>(cs...);
  }
 
  // ============================================================================
  // Functional Operations - Aleph Style
  // ============================================================================
 
  template <typename Pred, typename... Containers>
  [[nodiscard]] bool stl_zip_all(Pred && pred, const Containers &... cs)
  {
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      if (not std::forward<Pred>(pred)(it.get_curr()))
        return false;
    return true;
  }
 
  template <typename Pred, typename... Containers>
  [[nodiscard]] bool stl_zip_all_eq(Pred && pred, const Containers &... cs)
  {
    auto it = stl_zip_it(cs...);
    for (; it.has_curr(); it.next())
      if (not std::forward<Pred>(pred)(it.get_curr()))
        return false;
    return it.completed();
  }
 
  template <typename Pred, typename... Containers>
  [[nodiscard]] bool stl_zip_exists(Pred && pred, const Containers &... cs)
  {
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      if (std::forward<Pred>(pred)(it.get_curr()))
        return true;
    return false;
  }
 
  template <typename Pred, typename... Containers>
  [[nodiscard]] bool stl_zip_any(Pred && pred, const Containers &... cs)
  {
    return stl_zip_exists(std::forward<Pred>(pred), cs...);
  }
 
  template <typename Pred, typename... Containers>
  [[nodiscard]] bool stl_zip_none(Pred && pred, const Containers &... cs)
  {
    return not stl_zip_exists(std::forward<Pred>(pred), cs...);
  }
 
  template <typename Op, typename... Containers>
  void stl_zip_for_each(Op && op, const Containers &... cs)
  {
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      std::forward<Op>(op)(it.get_curr());
  }
 
  template <typename Op, typename... Containers>
  void stl_zip_for_each_indexed(Op && op, const Containers &... cs)
  {
    size_t idx = 0;
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next(), ++idx)
      std::forward<Op>(op)(idx, it.get_curr());
  }
 
  template <typename T, typename Op, typename... Containers>
  [[nodiscard]] T stl_zip_foldl(T init, Op && op, const Containers &... cs)
  {
    T acc = std::move(init);
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      acc = std::forward<Op>(op)(std::move(acc), it.get_curr());
    return acc;
  }
 
  template <typename T, typename Op, typename... Containers>
  [[nodiscard]] T stl_zip_reduce(T init, Op && op, const Containers &... cs)
  {
    return stl_zip_foldl(std::move(init), std::forward<Op>(op), cs...);
  }
 
  template <typename Op, typename... Containers>
  [[nodiscard]] auto stl_zip_map(Op && op, const Containers &... cs)
  {
    using TupleType = decltype(stl_zip_it(cs...).get_curr());
    using ResultType = std::decay_t<decltype(std::forward<Op>(op)(std::declval<TupleType>()))>;
 
    std::vector<ResultType> result;
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      result.push_back(std::forward<Op>(op)(it.get_curr()));
    return result;
  }
 
  template <typename Pred, typename... Containers>
  [[nodiscard]] auto stl_zip_filter(Pred && pred, const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
 
    std::vector<TupleType> result;
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      if (auto t = it.get_curr(); std::forward<Pred>(pred)(t))
        result.push_back(t);
    return result;
  }
 
  template <typename Pred, typename... Containers>
  [[nodiscard]] auto stl_zip_find_first(Pred && pred, const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
 
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      if (auto t = it.get_curr(); std::forward<Pred>(pred)(t))
        return std::optional<TupleType>(t);
    return std::optional<TupleType>{};
  }
 
  template <typename Pred, typename... Containers>
  [[nodiscard]] size_t stl_zip_count(Pred && pred, const Containers &... cs)
  {
    size_t count = 0;
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      if (std::forward<Pred>(pred)(it.get_curr()))
        ++count;
    return count;
  }
 
  template <typename... Containers>
  [[nodiscard]] size_t stl_zip_length(const Containers &... cs)
  {
    size_t count = 0;
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      ++count;
    return count;
  }
 
  template <typename... Containers>
  [[nodiscard]] bool stl_zip_equal_length(const Containers &... cs)
  {
    auto it = stl_zip_it(cs...);
    while (it.has_curr())
      it.next();
    return it.completed();
  }
 
  template <typename... Containers>
  [[nodiscard]] auto stl_zip_nth(const size_t n, const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
 
    size_t i = 0;
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next(), ++i)
      if (i == n)
        return std::optional<TupleType>(it.get_curr());
    return std::optional<TupleType>{};
  }
 
  template <typename... Containers>
  [[nodiscard]] auto stl_zip_take(const size_t n, const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
 
    std::vector<TupleType> result;
    result.reserve(n);
    size_t count = 0;
    for (auto it = stl_zip_it(cs...); it.has_curr() and count < n; it.next(), ++count)
      result.push_back(it.get_curr());
    return result;
  }
 
  template <typename... Containers>
  [[nodiscard]] auto stl_zip_drop(const size_t n, const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
 
    std::vector<TupleType> result;
    auto it = stl_zip_it(cs...);
 
    // Skip first n
    for (size_t i = 0; i < n and it.has_curr(); ++i)
      it.next();
 
    // Collect rest
    for (; it.has_curr(); it.next())
      result.push_back(it.get_curr());
    return result;
  }
 
  template <typename Pred, typename... Containers>
  [[nodiscard]] auto stl_zip_partition(Pred && pred, const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
 
    std::vector<TupleType> matching, non_matching;
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      if (auto t = it.get_curr(); std::forward<Pred>(pred)(t))
        matching.push_back(t);
      else
        non_matching.push_back(t);
    return std::make_pair(std::move(matching), std::move(non_matching));
  }
 
  template <typename... Containers>
  [[nodiscard]] auto stl_zip_to_vector(const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
 
    std::vector<TupleType> result;
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      result.push_back(it.get_curr());
    return result;
  }
 
  // ============================================================================
  // Traverse operations (like zip_traverse in ah-zip.H)
  // ============================================================================
 
  template <typename Pred, typename... Containers>
  [[nodiscard]] bool stl_zip_traverse(Pred && pred, const Containers &... cs)
  {
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      if (not std::forward<Pred>(pred)(it.get_curr()))
        return false;
    return true;
  }
 
  template <typename Pred, typename... Containers>
  [[nodiscard]] bool stl_zip_traverse_eq(Pred && pred, const Containers &... cs)
  {
    auto it = stl_zip_it(cs...);
    for (; it.has_curr(); it.next())
      if (not std::forward<Pred>(pred)(it.get_curr()))
        return false;
    return it.completed();
  }
 
  // ============================================================================
  // Comparison helpers
  // ============================================================================
 
  namespace stl_zip_detail
  {
    // Compare adjacent elements in a tuple
    template <typename Cmp, typename Tuple, size_t... Is>
    bool compare_adjacent_impl(Cmp & cmp, const Tuple & t, std::index_sequence<Is...>)
    {
      return (... and cmp(std::get<Is>(t), std::get<Is + 1>(t)));
    }
  }
 
  template <typename Cmp, typename... Containers>
  [[nodiscard]] bool stl_zip_cmp(Cmp && cmp, const Containers &... cs)
  {
    static_assert(sizeof...(Containers) >= 2, "stl_zip_cmp requires at least 2 containers");
 
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      {
        constexpr size_t N = sizeof...(Containers);
        if (auto t = it.get_curr(); not
          stl_zip_detail::compare_adjacent_impl(cmp, t, std::make_index_sequence<N - 1>{}))
          return false;
      }
    return true;
  }
 
  // ============================================================================
  // Enumerate - like Python's enumerate()
  // ============================================================================
 
  template <typename Container>
  class StlEnumerateIterator
  {
  public:
    using iterator_category = std::input_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = std::tuple<size_t, typename std::decay_t<Container>::value_type>;
 
  private:
    typename std::decay_t<Container>::const_iterator curr_;
    typename std::decay_t<Container>::const_iterator end_;
    size_t index_ = 0;
 
  public:
    explicit constexpr StlEnumerateIterator(const Container & c)
      : curr_(c.begin()), end_(c.end()), index_(0) {}
 
    struct end_tag
    {};
 
    constexpr StlEnumerateIterator(const Container & c, end_tag)
      : curr_(c.end()), end_(c.end()), index_(0) {}
 
    [[nodiscard]] constexpr bool has_curr() const noexcept { return curr_ != end_; }
 
    [[nodiscard]] constexpr auto get_curr() const { return std::make_tuple(index_, *curr_); }
 
    constexpr void next() noexcept
    {
      ++curr_;
      ++index_;
    }
 
    constexpr void next_ne() noexcept { next(); }
 
    [[nodiscard]] constexpr auto operator*() const { return get_curr(); }
 
    constexpr StlEnumerateIterator &operator++() noexcept
    {
      next();
      return *this;
    }
 
    [[nodiscard]] constexpr bool operator==(const StlEnumerateIterator & other) const noexcept
    {
      return not has_curr() and not other.has_curr();
    }
 
    [[nodiscard]] constexpr bool operator!=(const StlEnumerateIterator & other) const noexcept
    {
      return not (*this == other);
    }
  };
 
  template <typename Container>
  class StlEnumerateView
  {
    const std::decay_t<Container> & container_;
 
  public:
    using iterator = StlEnumerateIterator<std::decay_t<Container>>;
 
    explicit constexpr StlEnumerateView(const Container & c) : container_(c) {}
 
    [[nodiscard]] constexpr iterator begin() const { return iterator(container_); }
 
    [[nodiscard]] constexpr iterator end() const
    {
      return iterator(container_, typename iterator::end_tag{});
    }
  };
 
  template <typename Container>
  [[nodiscard]] constexpr auto stl_enumerate(const Container & c)
  {
    return StlEnumerateView<Container>(c);
  }
 
  // ============================================================================
  // Take while / Drop while
  // ============================================================================
 
  template <typename Pred, typename... Containers>
  [[nodiscard]] auto stl_zip_take_while(Pred && pred, const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
 
    std::vector<TupleType> result;
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      {
        auto t = it.get_curr();
        if (not std::forward<Pred>(pred)(t))
          break;
        result.push_back(t);
      }
    return result;
  }
 
  template <typename Pred, typename... Containers>
  [[nodiscard]] auto stl_zip_drop_while(Pred && pred, const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
 
    std::vector<TupleType> result;
    auto it = stl_zip_it(cs...);
 
    // Skip while pred is true
    for (; it.has_curr() and std::forward<Pred>(pred)(it.get_curr()); it.next())
      /* skip */;
 
    // Collect the rest
    for (; it.has_curr(); it.next())
      result.push_back(it.get_curr());
    return result;
  }
 
  // ============================================================================
  // First / Last convenience functions
  // ============================================================================
 
  template <typename... Containers>
  [[nodiscard]] auto stl_zip_first(const Containers &... cs)
  {
    return stl_zip_nth(0, cs...);
  }
 
  template <typename... Containers>
  [[nodiscard]] auto stl_zip_last(const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
 
    std::optional<TupleType> result;
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      result = it.get_curr();
    return result;
  }
 
  template <typename Pred, typename... Containers>
  [[nodiscard]] auto stl_zip_find_last(Pred && pred, const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
 
    std::optional<TupleType> result;
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      {
        auto t = it.get_curr();
        if (std::forward<Pred>(pred)(t))
          result = t;
      }
    return result;
  }
 
  template <typename Pred, typename... Containers>
  [[nodiscard]] size_t stl_zip_find_index(Pred && pred, const Containers &... cs)
  {
    size_t idx = 0;
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next(), ++idx)
      if (std::forward<Pred>(pred)(it.get_curr()))
        return idx;
    return idx;
  }
 
  // ============================================================================
  // Unzip - inverse of zip
  // ============================================================================
 
  template <typename T, typename U>
  [[nodiscard]] auto stl_unzip(const std::vector<std::pair<T, U>> & pairs)
  {
    std::vector<T> firsts;
    std::vector<U> seconds;
    firsts.reserve(pairs.size());
    seconds.reserve(pairs.size());
 
    for (const auto & [f, s]: pairs)
      {
        firsts.push_back(f);
        seconds.push_back(s);
      }
    return std::make_pair(std::move(firsts), std::move(seconds));
  }
 
  template <typename... Ts>
  [[nodiscard]] auto stl_unzip_tuple(const std::vector<std::tuple<Ts...>> & tuples)
  {
    std::tuple<std::vector<Ts>...> result;
 
    // Reserve space in each vector
    std::apply([&tuples](auto &... vecs)
                 {
                   (vecs.reserve(tuples.size()), ...);
                 }, result);
 
    // Populate vectors
    for (const auto & t: tuples)
      {
        std::apply([&t](auto &... vecs)
                     {
                       std::apply([&vecs...](const auto &... elems)
                                    {
                                      (vecs.push_back(elems), ...);
                                    }, t);
                     }, result);
      }
 
    return result;
  }
 
  // ============================================================================
  // Adjacent - zip consecutive elements of same container
  // ============================================================================
 
  template <typename Container>
  [[nodiscard]] auto stl_adjacent(const Container & c)
  {
    using T = typename std::decay_t<Container>::value_type;
    std::vector<std::pair<T, T>> result;
 
    auto it = c.begin();
    if (it == c.end())
      return result;
 
    auto prev = *it;
    ++it;
 
    for (; it != c.end(); ++it)
      {
        result.emplace_back(prev, *it);
        prev = *it;
      }
    return result;
  }
 
  template <typename Op, typename Container>
  [[nodiscard]] auto stl_adjacent_map(Op && op, const Container & c)
  {
    using T = typename std::decay_t<Container>::value_type;
    using R = std::decay_t<decltype(std::forward<Op>(op)(std::declval<T>(), std::declval<T>()))>;
 
    std::vector<R> result;
 
    auto it = c.begin();
    if (it == c.end())
      return result;
 
    auto prev = *it;
    ++it;
 
    for (; it != c.end(); ++it)
      {
        result.push_back(std::forward<Op>(op)(prev, *it));
        prev = *it;
      }
    return result;
  }
 
  // ============================================================================
  // Pairwise operations on single container
  // ============================================================================
 
  template <typename Pred, typename Container>
  [[nodiscard]] bool stl_adjacent_all(Pred && pred, const Container & c)
  {
    auto it = c.begin();
    if (it == c.end())
      return true;
 
    auto prev = *it;
    ++it;
 
    for (; it != c.end(); ++it)
      {
        if (not std::forward<Pred>(pred)(prev, *it))
          return false;
        prev = *it;
      }
    return true;
  }
 
  template <typename Pred, typename Container>
  [[nodiscard]] bool stl_adjacent_exists(Pred && pred, const Container & c)
  {
    auto it = c.begin();
    if (it == c.end())
      return false;
 
    auto prev = *it;
    ++it;
 
    for (; it != c.end(); ++it)
      {
        if (std::forward<Pred>(pred)(prev, *it))
          return true;
        prev = *it;
      }
    return false;
  }
 
  // ============================================================================
  // ML-style Additional Operations
  // ============================================================================
 
  template <typename Op, typename... Containers>
  [[nodiscard]] auto stl_zip_mapi(Op && op, const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
    using ResultType = std::decay_t<decltype(std::forward<Op>(op)(size_t{}, std::declval<TupleType>()))>;
 
    std::vector<ResultType> result;
    size_t idx = 0;
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next(), ++idx)
      result.push_back(std::forward<Op>(op)(idx, it.get_curr()));
    return result;
  }
 
  template <typename Pred, typename... Containers>
  [[nodiscard]] auto stl_zip_filteri(Pred && pred, const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
 
    std::vector<TupleType> result;
    size_t idx = 0;
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next(), ++idx)
      if (auto t = it.get_curr(); std::forward<Pred>(pred)(idx, t))
        result.push_back(t);
    return result;
  }
 
  template <typename T, typename Op, typename... Containers>
  [[nodiscard]] auto stl_zip_scan_left(T init, Op && op, const Containers &... cs)
  {
    std::vector<T> result;
    result.push_back(init);
 
    T acc = std::move(init);
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      {
        acc = std::forward<Op>(op)(std::move(acc), it.get_curr());
        result.push_back(acc);
      }
    return result;
  }
 
  template <typename Op, typename... Containers>
  [[nodiscard]] auto stl_zip_find_mapi(Op && op, const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
    using OptType = std::decay_t<decltype(std::forward<Op>(op)(size_t{}, std::declval<TupleType>()))>;
 
    size_t idx = 0;
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next(), ++idx)
      if (auto result = std::forward<Op>(op)(idx, it.get_curr()))
        return result;
    return OptType{};
  }
 
  template <typename... Containers>
  [[nodiscard]] bool stl_zip_equal(const Containers &... cs)
  {
    // For a single zip, check if all containers have equal length
    auto it = stl_zip_it(cs...);
    while (it.has_curr())
      it.next();
    return it.completed();
  }
 
  template <typename Eq, typename... Containers>
  [[nodiscard]] bool stl_zip_equal_by(Eq && eq, const Containers &... cs)
  {
    auto it = stl_zip_it(cs...);
    for (; it.has_curr(); it.next())
      if (not std::forward<Eq>(eq)(it.get_curr()))
        return false;
    return it.completed();
  }
 
  template <typename... Containers1, typename... Containers2>
  [[nodiscard]] int stl_zip_compare(
      const std::tuple<const Containers1 &...> & cs1,
      const std::tuple<const Containers2 &...> & cs2)
  {
    auto it1 = std::apply([](const auto &... cs) { return stl_zip_it(cs...); }, cs1);
    auto it2 = std::apply([](const auto &... cs) { return stl_zip_it(cs...); }, cs2);
 
    while (it1.has_curr() and it2.has_curr())
      {
        auto t1 = it1.get_curr();
        auto t2 = it2.get_curr();
        if (t1 < t2) return -1;
        if (t2 < t1) return 1;
        it1.next();
        it2.next();
      }
 
    if (it1.has_curr()) return 1; // first is longer
    if (it2.has_curr()) return -1; // second is longer
    return 0; // equal
  }
 
  template <typename Tuple, typename... Containers>
  [[nodiscard]] bool stl_zip_mem(const Tuple & target, const Containers &... cs)
  {
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      if (it.get_curr() == target)
        return true;
    return false;
  }
 
  template <typename Key, typename... Containers>
  [[nodiscard]] auto stl_zip_assoc(const Key & key, const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
 
    for (auto it = stl_zip_it(cs...); it.has_curr(); it.next())
      if (auto t = it.get_curr(); std::get<0>(t) == key)
        return std::optional<TupleType>(t);
    return std::optional<TupleType>{};
  }
 
  template <typename... Containers>
  [[nodiscard]] auto stl_zip_min(const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
 
    auto it = stl_zip_it(cs...);
    if (not it.has_curr())
      return std::optional<TupleType>{};
 
    TupleType min_val = it.get_curr();
    it.next();
 
    for (; it.has_curr(); it.next())
      {
        auto t = it.get_curr();
        if (t < min_val)
          min_val = t;
      }
    return std::optional<TupleType>(min_val);
  }
 
  template <typename... Containers>
  [[nodiscard]] auto stl_zip_max(const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
 
    auto it = stl_zip_it(cs...);
    if (not it.has_curr())
      return std::optional<TupleType>{};
 
    TupleType max_val = it.get_curr();
    it.next();
 
    for (; it.has_curr(); it.next())
      {
        auto t = it.get_curr();
        if (t > max_val)
          max_val = t;
      }
    return std::optional<TupleType>(max_val);
  }
 
  template <typename... Containers>
  [[nodiscard]] auto stl_zip_min_max(const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
    using ResultType = std::optional<std::pair<TupleType, TupleType>>;
 
    auto it = stl_zip_it(cs...);
    if (not it.has_curr())
      return ResultType{};
 
    TupleType min_val = it.get_curr();
    TupleType max_val = min_val;
    it.next();
 
    for (; it.has_curr(); it.next())
      {
        auto t = it.get_curr();
        if (t < min_val) min_val = t;
        if (t > max_val) max_val = t;
      }
    return ResultType(std::make_pair(min_val, max_val));
  }
 
  template <typename... Containers>
  [[nodiscard]] auto stl_zip_sum(const Containers &... cs)
  {
    using TupleType = typename StlZipIterator<std::decay_t<Containers>...>::value_type;
 
    auto it = stl_zip_it(cs...);
    if (not it.has_curr())
      return std::optional<TupleType>{};
 
    TupleType sum = it.get_curr();
    it.next();
 
    for (; it.has_curr(); it.next())
      {
        auto t = it.get_curr();
        std::apply([&t](auto &... sum_elems)
                     {
                       size_t i = 0;
                       ((sum_elems = sum_elems + std::get<decltype(i){}>(t), ++i), ...);
                     }, sum);
      }
    return std::optional<TupleType>(sum);
  }
} // end namespace Aleph
 
# endif // AH_STL_ZIP_H