ah-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_ZIP_H
#define AH_ZIP_H 1
 
#include <type_traits>
#include <tuple>
#include <vector>
 
#include <htlist.H>
#include <ahFunctional.H>
#include <tpl_dynSkipList.H>
 
namespace Aleph {
 
template <class HeadC, class... TailC>
class ZipIterator : public ZipIterator<TailC...>
{
  typename HeadC::Iterator it;
 
  using T = std::decay_t<typename HeadC::Item_Type>;
 
public:
  using Tuple_Type
    = decltype(std::tuple_cat(std::declval<std::tuple<T>>(),
                              std::declval<typename ZipIterator<TailC...>::Tuple_Type>()));
 
  using Item_Type = T;
 
  ZipIterator(const HeadC &head, const TailC &...tail) : ZipIterator<TailC...>(tail...), it(head) {}
 
  [[nodiscard]] bool has_curr() const noexcept
  {
    return it.has_curr() and ZipIterator<TailC...>::has_curr();
  }
 
  [[nodiscard]] bool completed() const noexcept
  {
    return not it.has_curr() and ZipIterator<TailC...>::completed();
  }
 
  auto get_curr() const
  {
    std::tuple<T> curr(it.get_curr());
    return std::tuple_cat(curr, ZipIterator<TailC...>::get_curr());
  }
 
  auto get_curr_ne() const noexcept
  {
    std::tuple<T> curr(it.get_curr_ne());
    return std::tuple_cat(curr, ZipIterator<TailC...>::get_curr_ne());
  }
 
  DynList<T> get_curr_list() const
  {
    DynList<T> l;
    l.append(it.get_curr());
    l.append(ZipIterator<TailC...>::get_curr_list());
    return l;
  }
 
  void next()
  {
    it.next();
    ZipIterator<TailC...>::next();
  }
 
  void next_ne() noexcept
  {
    it.next_ne();
    ZipIterator<TailC...>::next_ne();
  }
};
 
template <class C>
class ZipIterator<C> : public C::Iterator
{
public:
  using T = std::decay_t<typename C::Item_Type>;
 
  using Tuple_Type = std::tuple<T>;
 
  using Item_Type = T;
 
  ZipIterator(const C &c) : C::Iterator(c) {}
 
  std::tuple<T> get_curr() const
  {
    return std::tuple<T>(C::Iterator::get_curr());
  }
 
  std::tuple<T> get_curr_ne() const noexcept
  {
    return std::tuple<T>(C::Iterator::get_curr_ne());
  }
 
  DynList<T> get_curr_list() const
  {
    DynList<T> l;
    l.append(C::Iterator::get_curr());
    return l;
  }
 
  [[nodiscard]] bool completed() const noexcept
  {
    return not this->has_curr();
  }
};
 
template <class... Cs>
[[nodiscard]] inline ZipIterator<Cs...> get_zip_it(const Cs &...cs)
{
  return ZipIterator<Cs...>(cs...);
}
 
template <class... Cs>
[[nodiscard]] inline ZipIterator<Cs...> get_zip_it_pos(size_t pos, const Cs &...cs)
{
  ZipIterator<Cs...> ret(cs...);
  for (size_t i = 0; i < pos; ++i)
    ret.next();
  return ret;
}
 
template <class... Cs>
[[nodiscard]] inline ZipIterator<Cs...> zip_it(const Cs &...cs)
{
  return get_zip_it(cs...);
}
 
template <class... Cs>
[[nodiscard]] inline ZipIterator<Cs...> zip_it_pos(size_t pos, const Cs &...cs)
{
  return get_zip_it_pos(pos, cs...);
}
 
template <class... Cs>
[[nodiscard]] inline bool equal_length(const Cs &...cs)
{
  auto it = get_zip_it(cs...);
  for (/* already initialized */; it.has_curr(); it.next_ne())
    /* empty */;
 
  return it.completed();
}
 
template <class Op, class... Cs>
[[nodiscard]] inline bool zip_traverse(Op &&op, const Cs &...cs)
{
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne())
    if (not std::forward<Op>(op)(it.get_curr()))
      return false;
  return true;
}
 
template <class Op, class... Cs>
[[nodiscard]] inline bool zip_traverse_eq(Op &&op, const Cs &...cs)
{
  auto it = zip_it(cs...);
  for (; it.has_curr(); it.next_ne())
    if (not std::forward<Op>(op)(it.get_curr()))
      return false;
  return it.completed();
}
 
template <class Op, class... Cs>
inline void zip_for_each(Op &&op, const Cs &...cs)
{
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne())
    std::forward<Op>(op)(it.get_curr());
}
 
template <class Op, class... Cs>
inline void zip_for_each_eq(Op &&op, const Cs &...cs)
{
  auto it = get_zip_it(cs...);
  for (; it.has_curr(); it.next_ne())
    std::forward<Op>(op)(it.get_curr());
 
  ah_length_error_if(not it.completed()) << "zip_for_each_eq() containers sizes mismatch";
}
 
template <class Op, class... Cs>
[[nodiscard]] inline bool zip_all(Op &&op, const Cs &...cs)
{
  auto it = zip_it(cs...);
  for (; it.has_curr(); it.next_ne())
    if (not std::forward<Op>(op)(it.get_curr()))
      return false;
 
  return it.completed();
}
 
template <class Op, class... Cs>
[[nodiscard]] inline bool zip_all_short(Op &&op, const Cs &...cs)
{
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne())
    if (not std::forward<Op>(op)(it.get_curr()))
      return false;
 
  return true;
}
 
template <class Op, class... Cs>
[[nodiscard]] inline bool zip_forall(Op &&op, const Cs &...cs)
{
  return zip_all(std::forward<Op>(op), cs...);
}
 
template <class Op, class... Cs>
[[nodiscard]] inline bool zip_forall_short(Op &&op, const Cs &...cs)
{
  return zip_all_short(std::forward<Op>(op), cs...);
}
 
template <class Op, class... Cs>
[[nodiscard]] inline bool zip_exists(Op &&op, const Cs &...cs)
{
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne())
    if (std::forward<Op>(op)(it.get_curr()))
      return true;
 
  return false;
}
 
template <class Op, class... Cs>
[[nodiscard]] inline bool zip_any(Op &&op, const Cs &...cs)
{
  return zip_exists(std::forward<Op>(op), cs...);
}
 
template <class Op, class... Cs>
[[nodiscard]] inline bool zip_none(Op &&op, const Cs &...cs)
{
  return not zip_exists(std::forward<Op>(op), cs...);
}
 
template <class Op, class... Cs>
[[nodiscard]] inline size_t zip_count(Op &&op, const Cs &...cs)
{
  size_t count = 0;
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne())
    if (std::forward<Op>(op)(it.get_curr()))
      ++count;
  return count;
}
 
template <class... Cs>
[[nodiscard]] inline size_t zip_length(const Cs &...cs)
{
  size_t count = 0;
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne())
    ++count;
  return count;
}
 
template <class Op, class... Cs>
[[nodiscard]]
auto zip_find_first(Op &&op, const Cs &...cs)
{
  using ZipType = typename ZipIterator<Cs...>::Tuple_Type;
 
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne())
    if (auto t = it.get_curr(); std::forward<Op>(op)(t))
      return std::make_pair(t, true);
 
  return std::make_pair(ZipType{}, false);
}
 
template <class Op, class... Cs>
[[nodiscard]]
auto zip_find_last(Op &&op, const Cs &...cs)
{
  using ZipType = typename ZipIterator<Cs...>::Tuple_Type;
 
  ZipType result{};
  bool found = false;
 
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne())
    if (auto t = it.get_curr(); std::forward<Op>(op)(t))
      {
        result = t;
        found = true;
      }
 
  return std::make_pair(result, found);
}
 
template <class... Cs>
[[nodiscard]]
auto zip_nth(size_t n, const Cs &...cs)
{
  using ZipType = typename ZipIterator<Cs...>::Tuple_Type;
 
  size_t i = 0;
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne(), ++i)
    if (i == n)
      return std::make_pair(it.get_curr(), true);
 
  return std::make_pair(ZipType{}, false);
}
 
template <class... Cs>
[[nodiscard]]
auto zip_first(const Cs &...cs)
{
  return zip_nth(0, cs...);
}
 
template <typename T, class Op, class... Cs>
[[nodiscard]]
DynList<T> zip_maps(Op op, const Cs &...cs)
{
  DynList<T> ret;
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne())
    ret.append(op(it.get_curr()));
  return ret;
}
 
template <typename T, class Prop, class Op, class... Cs>
[[nodiscard]]
DynList<T> zip_maps_if(Prop prop, Op op, const Cs &...cs)
{
  DynList<T> ret;
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne())
    if (auto t = it.get_curr(); prop(t))
      ret.append(op(t));
 
  return ret;
}
 
template <typename T, class Op, class... Cs>
[[nodiscard]]
T zip_foldl(const T &init, Op op, const Cs &...cs)
{
  T acu = init;
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne())
    acu = op(acu, it.get_curr());
  return acu;
}
 
template <typename T, class Op, class... Cs>
[[nodiscard]]
T zip_foldl_eq(const T &init, Op op, const Cs &...cs)
{
  T acu = init;
  auto it = zip_it(cs...);
  for (; it.has_curr(); it.next_ne())
    acu = op(acu, it.get_curr());
 
  ah_length_error_if(not it.completed()) << "zip_foldl_eq() containers sizes mismatch";
 
  return acu;
}
 
template <typename T, class Op, class... Cs>
[[nodiscard]]
DynList<T> zip_maps_eq(Op op, const Cs &...cs)
{
  DynList<T> ret;
  auto it = zip_it(cs...);
  for (; it.has_curr(); it.next_ne())
    ret.append(op(it.get_curr()));
 
  ah_length_error_if(not it.completed()) << "zip_maps_eq() containers sizes mismatch";
 
  return ret;
}
 
template <typename T, class Prop, class Op, class... Cs>
[[nodiscard]]
DynList<T> zip_maps_if_eq(Prop prop, Op op, const Cs &...cs)
{
  DynList<T> ret;
  auto it = zip_it(cs...);
  for (; it.has_curr(); it.next_ne())
    if (auto t = it.get_curr(); prop(t))
      ret.append(op(t));
 
  ah_length_error_if(not it.completed()) << "zip_maps_if_eq() containers sizes mismatch";
 
  return ret;
}
 
template <class Op, class... Cs>
[[nodiscard]]
auto zip_map(Op &&op, const Cs &...cs)
{
  using ZipType = typename ZipIterator<Cs...>::Tuple_Type;
  using ResultType = std::decay_t<decltype(std::forward<Op>(op)(std::declval<ZipType>()))>;
 
  DynList<ResultType> ret;
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne())
    ret.append(std::forward<Op>(op)(it.get_curr()));
  return ret;
}
 
template <class Op, class... Cs>
[[nodiscard]]
auto zip_map_eq(Op &&op, const Cs &...cs)
{
  using ZipType = typename ZipIterator<Cs...>::Tuple_Type;
  using ResultType = std::decay_t<decltype(std::forward<Op>(op)(std::declval<ZipType>()))>;
 
  DynList<ResultType> ret;
  auto it = zip_it(cs...);
  for (; it.has_curr(); it.next_ne())
    ret.append(std::forward<Op>(op)(it.get_curr()));
 
  ah_length_error_if(not it.completed()) << "zip_map_eq() containers sizes mismatch";
 
  return ret;
}
 
template <class Op, class... Cs>
[[nodiscard]]
auto zip_filter(Op op, const Cs &...cs)
{
  using ZipType = decltype(zip_it(cs...).get_curr());
 
  DynList<ZipType> ret;
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne())
    if (auto t = it.get_curr(); op(t))
      ret.append(t);
 
  return ret;
}
 
template <class Op, class... Cs>
[[nodiscard]]
auto zip_filter_eq(Op op, const Cs &...cs)
{
  using ZipType = decltype(zip_it(cs...).get_curr());
 
  DynList<ZipType> ret;
  auto it = zip_it(cs...);
  for (; it.has_curr(); it.next_ne())
    if (auto t = it.get_curr(); op(t))
      ret.append(t);
 
  ah_length_error_if(not it.completed()) << "zip_filter_eq() containers sizes mismatch";
 
  return ret;
}
 
namespace zip_detail {
template <class Cmp, class Tuple, size_t... Is>
bool compare_adjacent(Cmp &cmp, const Tuple &t, std::index_sequence<Is...>)
{
  // Compare t[0] with t[1], t[1] with t[2], etc.
  return (... and cmp(std::get<Is>(t), std::get<Is + 1>(t)));
}
}  // namespace zip_detail
 
template <class Cmp, class... Cs>
[[nodiscard]]
bool zip_cmp(Cmp cmp, const Cs &...cs)
{
  constexpr size_t N = sizeof...(Cs);
  static_assert(N >= 2, "zip_cmp requires at least 2 containers");
 
  for (auto it = get_zip_it(cs...); it.has_curr(); it.next_ne())
    if (auto t = it.get_curr();
        not zip_detail::compare_adjacent(cmp, t, std::make_index_sequence<N - 1>{}))
      return false;
 
  return true;
}
 
template <class Op, class... Cs>
[[nodiscard]]
size_t zip_find_index(Op op, const Cs &...cs)
{
  size_t i = 0;
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne(), ++i)
    if (auto t = it.get_curr(); op(t))
      break;
 
  return i;
}
 
template <class Op, class... Cs>
[[nodiscard]]
auto zip_partition(Op op, const Cs &...cs)
{
  using ZipType = decltype(zip_it(cs...).get_curr());
 
  DynList<ZipType> ret1, ret2;
  size_t n1 = 0, n2 = 0;
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne())
    if (auto t = it.get_curr(); op(t))
      {
        ret1.append(t);
        ++n1;
      }
    else
      {
        ret2.append(t);
        ++n2;
      }
 
  return std::make_tuple(ret1, n1, ret2, n2);
}
 
template <class... Cs>
[[nodiscard]] inline auto t_zip(const Cs &...cs)
{
  auto it = zip_it(cs...);
  using T = decltype(it.get_curr());
  DynList<T> ret;
  for (; it.has_curr(); it.next_ne())
    ret.append(it.get_curr());
 
  return ret;
}
 
template <class... Cs>
[[nodiscard]] inline auto t_zip_eq(const Cs &...cs)
{
  auto it = zip_it(cs...);
  using T = decltype(it.get_curr());
  DynList<T> ret;
  for (; it.has_curr(); it.next_ne())
    ret.append(it.get_curr());
 
  ah_length_error_if(not it.completed()) << "Container sizes mismatch";
 
  return ret;
}
 
template <class HeadC, class... TailC>
class EnumZipIterator : public EnumZipIterator<TailC...>
{
  typename HeadC::Iterator it;
 
  using T = std::decay_t<typename HeadC::Item_Type>;
 
public:
  EnumZipIterator(const HeadC &head, const TailC &...tail)
    : EnumZipIterator<TailC...>(tail...), it(head)
  {}
 
  [[nodiscard]] bool has_curr() const noexcept
  {
    return it.has_curr() and EnumZipIterator<TailC...>::has_curr();
  }
 
  [[nodiscard]] bool completed() const noexcept
  {
    return not it.has_curr() and EnumZipIterator<TailC...>::completed();
  }
 
  auto get_curr() const
  {
    std::tuple<T> curr(it.get_curr());
    return std::tuple_cat(curr, EnumZipIterator<TailC...>::get_curr());
  }
 
  void next()
  {
    it.next();
    EnumZipIterator<TailC...>::next();
  }
 
  auto get_curr_ne() const noexcept
  {
    std::tuple<T> curr(it.get_curr_ne());
    return std::tuple_cat(curr, EnumZipIterator<TailC...>::get_curr_ne());
  }
 
  void next_ne() noexcept
  {
    it.next_ne();
    EnumZipIterator<TailC...>::next_ne();
  }
};
 
template <class C>
class EnumZipIterator<C> : public C::Iterator
{
  size_t i = 0;
 
public:
  void next()
  {
    C::Iterator::next();
    ++i;
  }
 
  void next_ne() noexcept
  {
    C::Iterator::next_ne();
    ++i;
  }
 
  using T = std::decay_t<typename C::Item_Type>;
 
  EnumZipIterator(const C &c) : C::Iterator(c) {}
 
  std::tuple<T, size_t> get_curr() const
  {
    return std::tuple<T, size_t>(C::Iterator::get_curr(), i);
  }
 
  std::tuple<T, size_t> get_curr_ne() const noexcept
  {
    return std::tuple<T, size_t>(C::Iterator::get_curr_ne(), i);
  }
 
  [[nodiscard]] bool completed() const noexcept
  {
    return not this->has_curr();
  }
};
 
template <class... Cs>
[[nodiscard]] inline EnumZipIterator<Cs...> get_enum_zip_it(const Cs &...cs)
{
  return EnumZipIterator<Cs...>(cs...);
}
 
template <class C, class... Cs>
[[nodiscard]] inline EnumZipIterator<C, Cs...> get_enum_zip_it_pos(size_t pos,
                                                                   const C &c,
                                                                   const Cs &...cs)
{
  EnumZipIterator<C, Cs...> ret(c, cs...);
  for (size_t i = 0; i < pos; ++i)
    ret.next();
 
  return ret;
}
 
template <class... Cs>
[[nodiscard]] inline EnumZipIterator<Cs...> enum_zip_it(const Cs &...cs)
{
  return EnumZipIterator<Cs...>(cs...);
}
 
template <class... Cs>
[[nodiscard]] inline EnumZipIterator<Cs...> enum_zip_it_pos(size_t pos, const Cs &...cs)
{
  return get_enum_zip_it_pos(pos, cs...);
}
 
template <class... Cs>
[[nodiscard]] inline auto t_enum_zip(const Cs &...cs)
{
  auto it = get_enum_zip_it(cs...);
  using T = decltype(it.get_curr());
  DynList<T> ret;
  for (; it.has_curr(); it.next_ne())
    ret.append(it.get_curr());
 
  return ret;
}
 
template <class... Cs>
[[nodiscard]] inline auto t_enum_zip_eq(const Cs &...cs)
{
  auto it = get_enum_zip_it(cs...);
  using T = decltype(it.get_curr());
  DynList<T> ret;
  for (; it.has_curr(); it.next_ne())
    ret.append(it.get_curr());
 
  ah_length_error_if(not it.completed()) << "Container sizes mismatch";
 
  return ret;
}
 
template <typename... Ts, size_t... is>
static inline auto t_unzip_impl(const DynList<std::tuple<Ts...>> &l, std::index_sequence<is...>)
{
  std::tuple<DynList<Ts>...> ret;
  for (auto it = l.get_it(); it.has_curr(); it.next_ne())
    std::initializer_list<int>{(std::get<is>(ret).append(std::get<is>(it.get_curr())), 0)...};
 
  return ret;
}
 
template <class... Ts>
[[nodiscard]] inline auto t_unzip(const DynList<std::tuple<Ts...>> &tuples)
{
  return t_unzip_impl(tuples, std::index_sequence_for<Ts...>{});
}
 
template <class C, typename... Lists>
[[nodiscard]]
auto zip_lists(const C &c, const Lists &...lists)
{
  using T = typename C::Item_Type;
  DynList<DynList<T>> ret;
  for (auto it = get_zip_it(c, lists...); it.has_curr(); it.next_ne())
    ret.append(it.get_curr_list());
  return ret;
}
 
template <class C, typename... Lists>
[[nodiscard]]
auto zip_lists_eq(const C &c, const Lists &...lists)
{
  using T = typename C::Item_Type;
  DynList<DynList<T>> ret;
  auto it = get_zip_it(c, lists...);
  for (; it.has_curr(); it.next_ne())
    ret.append(it.get_curr_list());
 
  ah_length_error_if(not it.completed()) << "zip_list_eq: container sizes mismatch";
 
  return ret;
}
 
namespace std_zip_detail {
template <typename... Its>
bool all_valid(const Its &...its)
{
  return (... and (its.first != its.second));
}
 
template <typename... Its>
void advance_all(Its &...its)
{
  (++its.first, ...);
}
 
template <typename... Its>
auto deref_all(const Its &...its)
{
  return std::make_tuple(*its.first...);
}
}  // namespace std_zip_detail
 
template <typename C1, typename C2>
[[nodiscard]]
auto std_zip(const C1 &c1, const C2 &c2)
{
  using T = typename C1::value_type;
  using U = typename C2::value_type;
  std::vector<std::pair<T, U>> result;
  auto it1 = c1.begin();
  auto it2 = c2.begin();
  for (; it1 != c1.end() and it2 != c2.end(); ++it1, ++it2)
    result.emplace_back(*it1, *it2);
  return result;
}
 
template <typename... Cs>
[[nodiscard]]
auto tzip_std(const Cs &...cs)
{
  static_assert(sizeof...(Cs) >= 2, "tzip_std requires at least 2 containers");
 
  using TupleType = std::tuple<typename Cs::value_type...>;
  std::vector<TupleType> ret;
 
  // Create iterator pairs (begin, end) for each container
  auto iters = std::make_tuple(std::make_pair(cs.begin(), cs.end())...);
 
  // Helper to check all iterators and build tuples
  auto check_and_push = [&ret](auto &...its)
  {
    while (std_zip_detail::all_valid(its...))
      {
        ret.push_back(std_zip_detail::deref_all(its...));
        std_zip_detail::advance_all(its...);
      }
  };
 
  std::apply(check_and_push, iters);
  return ret;
}
 
template <typename... Cs>
[[nodiscard]]
auto std_zip_n(const Cs &...cs)
{
  return tzip_std(cs...);
}
 
template <class Op, class... Cs>
[[nodiscard]]
auto zip_transform(Op &&op, const Cs &...cs)
{
  using ZipType = decltype(zip_it(cs...).get_curr());
  using ResultType = std::decay_t<decltype(std::forward<Op>(op)(std::declval<ZipType>()))>;
 
  std::vector<ResultType> ret;
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne())
    ret.push_back(std::forward<Op>(op)(it.get_curr()));
  return ret;
}
 
template <class Op, class... Cs>
[[nodiscard]]
auto zip_transform_eq(Op &&op, const Cs &...cs)
{
  using ZipType = decltype(zip_it(cs...).get_curr());
  using ResultType = std::decay_t<decltype(std::forward<Op>(op)(std::declval<ZipType>()))>;
 
  std::vector<ResultType> ret;
  auto it = zip_it(cs...);
  for (; it.has_curr(); it.next_ne())
    ret.push_back(std::forward<Op>(op)(it.get_curr()));
 
  ah_length_error_if(not it.completed()) << "zip_transform_eq() containers sizes mismatch";
  return ret;
}
 
template <class Op, class... Cs>
inline void zip_for_each_indexed(Op &&op, const Cs &...cs)
{
  size_t idx = 0;
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne(), ++idx)
    std::forward<Op>(op)(idx, it.get_curr());
}
 
template <class Op, class... Cs>
inline void zip_for_each_indexed_eq(Op &&op, const Cs &...cs)
{
  size_t idx = 0;
  auto it = zip_it(cs...);
  for (; it.has_curr(); it.next_ne(), ++idx)
    std::forward<Op>(op)(idx, it.get_curr());
 
  ah_length_error_if(not it.completed()) << "zip_for_each_indexed_eq() containers sizes mismatch";
}
 
template <class... Cs>
[[nodiscard]]
auto zip_take(size_t n, const Cs &...cs)
{
  using ZipType = decltype(zip_it(cs...).get_curr());
  DynList<ZipType> ret;
  size_t count = 0;
  for (auto it = zip_it(cs...); it.has_curr() and count < n; it.next_ne(), ++count)
    ret.append(it.get_curr());
  return ret;
}
 
template <class... Cs>
[[nodiscard]]
auto zip_drop(const size_t n, const Cs &...cs)
{
  using ZipType = decltype(zip_it(cs...).get_curr());
  DynList<ZipType> ret;
  auto it = zip_it(cs...);
 
  // Skip first n elements
  for (size_t i = 0; i < n and it.has_curr(); ++i)
    it.next_ne();
 
  // Collect the rest
  for (; it.has_curr(); it.next_ne())
    ret.append(it.get_curr());
  return ret;
}
 
template <class Pred, class... Cs>
[[nodiscard]]
auto zip_take_while(Pred &&pred, const Cs &...cs)
{
  using ZipType = decltype(zip_it(cs...).get_curr());
  DynList<ZipType> ret;
  for (auto it = zip_it(cs...); it.has_curr(); it.next_ne())
    {
      auto t = it.get_curr();
      if (not std::forward<Pred>(pred)(t))
        break;
      ret.append(t);
    }
  return ret;
}
 
template <class Pred, class... Cs>
[[nodiscard]]
auto zip_drop_while(Pred &&pred, const Cs &...cs)
{
  using ZipType = decltype(zip_it(cs...).get_curr());
  DynList<ZipType> ret;
  auto it = zip_it(cs...);
 
  // Skip while pred is true
  for (; it.has_curr() and std::forward<Pred>(pred)(it.get_curr()); it.next_ne())
    /* skip */;
 
  // Collect the rest
  for (; it.has_curr(); it.next_ne())
    ret.append(it.get_curr());
  return ret;
}
 
// ============================================================================
// Index sequence helpers
// ============================================================================
 
namespace zip_index_detail {
template <class Op, class Tuple, size_t... Is>
void for_each_in_tuple_impl(Op &&op, Tuple &&t, std::index_sequence<Is...>)
{
  (std::forward<Op>(op)(std::get<Is>(std::forward<Tuple>(t))), ...);
}
 
template <class Op, class Tuple, size_t... Is>
auto transform_tuple_impl(Op &&op, Tuple &&t, std::index_sequence<Is...>)
{
  return std::make_tuple(std::forward<Op>(op)(std::get<Is>(std::forward<Tuple>(t)))...);
}
 
template <class Pred, class Tuple, size_t... Is>
bool all_of_tuple_impl(Pred &&pred, const Tuple &t, std::index_sequence<Is...>)
{
  return (... and std::forward<Pred>(pred)(std::get<Is>(t)));
}
 
template <class Pred, class Tuple, size_t... Is>
bool any_of_tuple_impl(Pred &&pred, const Tuple &t, std::index_sequence<Is...>)
{
  return (... or std::forward<Pred>(pred)(std::get<Is>(t)));
}
}  // namespace zip_index_detail
 
template <class Op, class Tuple>
void for_each_in_tuple(Op &&op, Tuple &&t)
{
  constexpr auto N = std::tuple_size_v<std::decay_t<Tuple>>;
  zip_index_detail::for_each_in_tuple_impl(std::forward<Op>(op),
                                           std::forward<Tuple>(t),
                                           std::make_index_sequence<N>{});
}
 
template <class Op, class Tuple>
[[nodiscard]]
auto transform_tuple(Op &&op, Tuple &&t)
{
  constexpr auto N = std::tuple_size_v<std::decay_t<Tuple>>;
  return zip_index_detail::transform_tuple_impl(std::forward<Op>(op),
                                                std::forward<Tuple>(t),
                                                std::make_index_sequence<N>{});
}
 
template <class Pred, class Tuple>
[[nodiscard]]
bool all_of_tuple(Pred &&pred, const Tuple &t)
{
  constexpr auto N = std::tuple_size_v<std::decay_t<Tuple>>;
  return zip_index_detail::all_of_tuple_impl(std::forward<Pred>(pred),
                                             t,
                                             std::make_index_sequence<N>{});
}
 
template <class Pred, class Tuple>
[[nodiscard]]
bool any_of_tuple(Pred &&pred, const Tuple &t)
{
  constexpr auto N = std::tuple_size_v<std::decay_t<Tuple>>;
  return zip_index_detail::any_of_tuple_impl(std::forward<Pred>(pred),
                                             t,
                                             std::make_index_sequence<N>{});
}
 
template <class Pred, class Tuple>
[[nodiscard]]
bool none_of_tuple(Pred &&pred, const Tuple &t)
{
  return not any_of_tuple(std::forward<Pred>(pred), t);
}
 
}  // end namespace Aleph
 
#endif  // AH_ZIP_H