ah-dry-mixin.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_DRY_MIXIN_H
#define AH_DRY_MIXIN_H
 
#include <cstddef>
#include <tuple>
#include <functional>
#include <utility>
#include <type_traits>
#include <vector>
#include <string>
 
#include <ah-concepts.H>
#include <ah-errors.H>
 
namespace Aleph
{
 
// Forward declarations
template<typename T> class DynList;
 
// Dft_Map_Op is defined in ahFunctional.H, we just forward declare here
// to avoid circular dependency. When ahFunctional.H is included, it provides
// the actual definition.
template <typename T, typename R> struct Dft_Map_Op;
 
 
// =============================================================================
// TraverseMixin - Basic traversal operations
// =============================================================================
 
template <typename Derived, typename Type>
class TraverseMixin
{
protected:
  [[nodiscard]] const Derived& self() const noexcept
  {
    return static_cast<const Derived&>(*this);
  }
 
  [[nodiscard]] Derived& self() noexcept
  {
    return static_cast<Derived&>(*this);
  }
 
public:
  template <class Operation>
    requires PredicateWith<Operation &, typename concepts_detail::traverse_arg<Derived, Operation>::type>
  bool traverse(Operation & operation) const
  {
    for (typename Derived::Iterator it(self()); it.has_curr(); it.next_ne())
      if (not operation(it.get_curr()))
        return false;
    return true;
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, typename concepts_detail::traverse_arg<Derived, Operation>::type>
  bool traverse(Operation & operation)
  {
    for (typename Derived::Iterator it(self()); it.has_curr(); it.next_ne())
      if (not operation(it.get_curr()))
        return false;
    return true;
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, typename concepts_detail::traverse_arg<Derived, Operation>::type>
  bool traverse(Operation and operation = Operation()) const
  {
    return traverse<Operation>(operation);
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, typename concepts_detail::traverse_arg<Derived, Operation>::type>
  bool traverse(Operation and operation = Operation())
  {
    return traverse<Operation>(operation);
  }
};
 
 
// =============================================================================
// LocateMixin - Element location operations
// =============================================================================
 
template <typename Derived, typename Type>
class LocateMixin
{
protected:
  [[nodiscard]] const Derived& self() const noexcept
  {
    return static_cast<const Derived&>(*this);
  }
 
  [[nodiscard]] Derived& self() noexcept
  {
    return static_cast<Derived&>(*this);
  }
 
public:
  Type & nth(const size_t n) const
  {
    Type * ptr = nullptr;
    size_t i = 0;
    self().traverse([&ptr, &i, &n] (Type & item)
    {
      if (i++ < n)
        return true;
      ptr = &item;
      return false;
    });
 
    ah_out_of_range_error_if(i != n + 1) << "index " << n << " out of range";
 
    return *ptr;
  }
 
  Type & nth_ne(const size_t n) const noexcept
  {
    Type * ptr = nullptr;
    size_t i = 0;
    self().traverse([&ptr, &i, &n] (Type & item)
    {
      if (i++ < n)
        return true;
      ptr = &item;
      return false;
    });
    return *ptr;
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, Type &>
  Type * find_ptr(Operation & operation)
  {
    Type * ptr = nullptr;
    self().traverse([&ptr, &operation] (Type & item)
    {
      if (operation(item))
      {
        ptr = &item;
        return false;
      }
      return true;
    });
    return ptr;
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, Type &>
  Type * find_ptr(Operation & operation) const
  {
    Type * ptr = nullptr;
    self().traverse([&ptr, &operation] (Type & item)
    {
      if (operation(item))
      {
        ptr = &item;
        return false;
      }
      return true;
    });
    return ptr;
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, Type &>
  Type * find_ptr(Operation and operation = Operation()) const
  {
    return find_ptr<Operation>(operation);
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, Type &>
  Type * find_ptr(Operation and operation = Operation())
  {
    return find_ptr<Operation>(operation);
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, Type &>
  std::tuple<bool, Type> find_item(Operation & operation)
  {
    auto ptr = find_ptr(operation);
    return ptr ? std::make_tuple(true, *ptr) : std::make_tuple(false, Type());
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, Type &>
  std::tuple<bool, Type> find_item(Operation & operation) const
  {
    auto ptr = find_ptr(operation);
    return ptr ? std::make_tuple(true, *ptr) : std::make_tuple(false, Type());
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, Type &>
  std::tuple<bool, Type> find_item(Operation && operation = Operation())
  {
    return find_item(operation);
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, Type &>
  std::tuple<bool, Type> find_item(Operation && operation = Operation()) const
  {
    return find_item(operation);
  }
};
 
 
// =============================================================================
// FunctionalMixin - Functional programming operations
// =============================================================================
 
template <typename Derived, typename Type>
class FunctionalMixin
{
protected:
  [[nodiscard]] const Derived& self() const noexcept
  {
    return static_cast<const Derived&>(*this);
  }
 
  [[nodiscard]] Derived& self() noexcept
  {
    return static_cast<Derived&>(*this);
  }
 
public:
 
  // ---------------------------------------------------------------------------
  // Iteration
  // ---------------------------------------------------------------------------
 
  template <class Operation>
    requires CallableWith<Operation &, const Type &>
  auto for_each(Operation & operation) const -> decltype(self())
  {
    self().traverse([&operation] (const Type & item)
    {
      operation(item);
      return true;
    });
    return self();
  }
 
  template <class Operation>
    requires CallableWith<Operation &, const Type &>
  auto for_each(Operation & operation) -> decltype(self())
  {
    self().traverse([&operation] (const Type & item)
    {
      operation(item);
      return true;
    });
    return self();
  }
 
  template <class Operation>
    requires CallableWith<Operation &, const Type &>
  auto for_each(Operation && operation = Operation()) const -> decltype(self())
  {
    return for_each<Operation>(operation);
  }
 
  template <class Operation>
    requires CallableWith<Operation &, const Type &>
  auto for_each(Operation && operation = Operation()) -> decltype(self())
  {
    return for_each<Operation>(operation);
  }
 
  template <class Operation>
    requires CallableWith<Operation &, Type &>
  auto mutable_for_each(Operation & operation) -> decltype(self())
  {
    self().traverse([&operation] (Type & item)
    {
      operation(item);
      return true;
    });
    return self();
  }
 
  template <class Operation>
    requires CallableWith<Operation &, Type &>
  auto mutable_for_each(Operation && operation = Operation()) -> decltype(self())
  {
    return mutable_for_each<Operation>(operation);
  }
 
  // ---------------------------------------------------------------------------
  // Predicates
  // ---------------------------------------------------------------------------
 
  template <class Operation>
    requires requires(const typename concepts_detail::defer<Derived, Operation>::type &c, Operation &op) { { c.template traverse<Operation>(op) } -> std::convertible_to<bool>; }
  [[nodiscard]] bool all(Operation & operation) const
  {
    return self().template traverse<Operation>(operation);
  }
 
  template <class Operation>
    requires requires(const typename concepts_detail::defer<Derived, Operation>::type &c, Operation &op) { { c.template traverse<Operation>(op) } -> std::convertible_to<bool>; }
  [[nodiscard]] bool all(Operation && operation = Operation()) const
  {
    return all<Operation>(operation);
  }
 
  template <class Operation>
    requires requires(const typename concepts_detail::defer<Derived, Operation>::type &c, Operation &op) { { c.template traverse<Operation>(op) } -> std::convertible_to<bool>; }
  [[nodiscard]] bool forall(Operation & operation) const
  {
    return all<Operation>(operation);
  }
 
  template <class Operation>
    requires requires(const typename concepts_detail::defer<Derived, Operation>::type &c, Operation &op) { { c.template traverse<Operation>(op) } -> std::convertible_to<bool>; }
  [[nodiscard]] bool forall(Operation && operation = Operation()) const
  {
    return all<Operation>(operation);
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, const Type &>
  [[nodiscard]] bool exists(Operation & operation) const
  {
    return not self().traverse([&operation] (const Type & item)
    {
      return not operation(item);
    });
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, const Type &>
  [[nodiscard]] bool exists(Operation && operation = Operation()) const
  {
    return exists<Operation>(operation);
  }
 
  // ---------------------------------------------------------------------------
  // Transformation
  // ---------------------------------------------------------------------------
 
  template <typename __Type = Type,
            template <typename> class Container = Aleph::DynList,
            class Operation = Dft_Map_Op<Type, __Type>>
    requires requires(Container<__Type> &l, Operation &op, const Type &item) { l.append(op(item)); }
  [[nodiscard]] Container<__Type> maps(Operation & operation) const
  {
    Container<__Type> ret_val;
    for_each([&ret_val, &operation] (const Type & item)
    {
      ret_val.append(operation(item));
    });
    return ret_val;
  }
 
  template <typename __Type = Type,
            template <typename> class Container = Aleph::DynList,
            class Operation = Dft_Map_Op<Type, __Type>>
    requires requires(Container<__Type> &l, Operation &op, const Type &item) { l.append(op(item)); }
  [[nodiscard]] Container<__Type> maps(Operation && operation = Operation()) const
  {
    return maps<__Type, Container, Operation>(operation);
  }
 
  template <typename __Type = Type>
  [[nodiscard]] __Type foldl(const __Type & init,
                             std::function<__Type(const __Type&, const Type&)> operation) const
  {
    auto ret_val = init;
    for_each([&ret_val, &operation] (const Type & item)
    {
      ret_val = operation(ret_val, item);
    });
    return ret_val;
  }
 
  template <typename __Type = Type>
  [[nodiscard]] __Type fold_left(std::function<__Type(const __Type&, const Type&)> operation,
                                 const __Type & init) const
  {
    return foldl<__Type>(init, operation);
  }
 
  template <class Operation>
    requires requires(Type &acc, Operation &op, const Type &item) { acc = op(acc, item); }
  [[nodiscard]] Type fold(const Type & init, Operation & operation) const
  {
    auto ret_val = init;
    for_each([&ret_val, &operation] (const Type & item)
    {
      ret_val = operation(ret_val, item);
    });
    return ret_val;
  }
 
  template <class Operation>
    requires requires(Type &acc, Operation &op, const Type &item) { acc = op(acc, item); }
  [[nodiscard]] Type fold(const Type & init, Operation && operation = Operation()) const
  {
    return fold<Operation>(init, operation);
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, const Type &>
  [[nodiscard]] DynList<Type> filter(Operation & operation) const
  {
    DynList<Type> ret_val;
    for_each([&ret_val, &operation] (const Type & item)
    {
      if (operation(item))
        ret_val.append(item);
    });
    return ret_val;
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, const Type &>
  [[nodiscard]] DynList<Type> filter(Operation && operation = Operation()) const
  {
    return filter<Operation>(operation);
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, const Type &>
  [[nodiscard]] DynList<std::tuple<Type, size_t>> pfilter(Operation & operation) const
  {
    DynList<std::tuple<Type, size_t>> ret_val;
    size_t i = 0;
    for_each([&ret_val, &operation, &i] (const Type & item)
    {
      if (operation(item))
        ret_val.append(std::make_tuple(item, i));
      ++i;
    });
    return ret_val;
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, const Type &>
  [[nodiscard]] DynList<std::tuple<Type, size_t>> pfilter(Operation && operation = Operation()) const
  {
    return pfilter<Operation>(operation);
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, const Type &>
  [[nodiscard]] std::pair<DynList<Type>, DynList<Type>> partition(Operation & op) const
  {
    std::pair<DynList<Type>, DynList<Type>> ret_val;
    for_each([&ret_val, &op] (const Type & item)
    {
      if (op(item))
        ret_val.first.append(item);
      else
        ret_val.second.append(item);
    });
    return ret_val;
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, const Type &>
  [[nodiscard]] std::pair<DynList<Type>, DynList<Type>> partition(Operation && op = Operation()) const
  {
    return partition<Operation>(op);
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, const Type &>
  [[nodiscard]] std::tuple<DynList<Type>, DynList<Type>> tpartition(Operation & op) const
  {
    DynList<Type> r1, r2;
    for_each([&r1, &r2, &op] (const Type & item)
    {
      if (op(item))
        r1.append(item);
      else
        r2.append(item);
    });
    return std::make_tuple(r1, r2);
  }
 
  template <class Operation>
    requires PredicateWith<Operation &, const Type &>
  [[nodiscard]] std::tuple<DynList<Type>, DynList<Type>> tpartition(Operation && op = Operation()) const
  {
    return tpartition<Operation>(op);
  }
 
  // ---------------------------------------------------------------------------
  // Utility
  // ---------------------------------------------------------------------------
 
  [[nodiscard]] size_t length() const noexcept
  {
    size_t count = 0;
    for_each([&count] (const Type &) { ++count; });
    return count;
  }
 
  template <template <typename> class Container = Aleph::DynList>
  [[nodiscard]] Container<Type> rev() const
  {
    Container<Type> ret_val;
    for_each([&ret_val] (const Type & item)
    {
      ret_val.insert(item);
    });
    return ret_val;
  }
 
  // ---------------------------------------------------------------------------
  // Slicing
  // ---------------------------------------------------------------------------
 
  template <template <typename> class Container = Aleph::DynList>
  [[nodiscard]] Container<Type> take(const size_t n) const
  {
    size_t i = 0;
    Container<Type> ret;
    self().traverse([&i, &ret, n] (const Type & item)
    {
      if (i++ >= n)
        return false;
      ret.append(item);
      return true;
    });
    return ret;
  }
 
  template <template <typename> class Container = Aleph::DynList>
  [[nodiscard]] Container<Type> drop(const size_t n) const
  {
    size_t i = 0;
    Container<Type> ret;
    self().traverse([&i, &ret, n] (const Type & item)
    {
      if (i++ >= n)
        ret.append(item);
      return true;
    });
    return ret;
  }
 
  // ---------------------------------------------------------------------------
  // Aggregation (Numeric)
  // ---------------------------------------------------------------------------
 
  [[nodiscard]] Type sum(const Type & init = Type{}) const
    requires requires(Type a, Type b) { { a + b } -> std::convertible_to<Type>; }
  {
    Type result = init;
    for_each([&result] (const Type & item)
    {
      result = result + item;
    });
    return result;
  }
 
  [[nodiscard]] Type product(const Type & init) const
    requires requires(Type a, Type b) { { a * b } -> std::convertible_to<Type>; }
  {
    Type result = init;
    for_each([&result] (const Type & item)
    {
      result = result * item;
    });
    return result;
  }
 
  [[nodiscard]] const Type * min() const
    requires requires(Type a, Type b) { { a < b } -> std::convertible_to<bool>; }
  {
    const Type * result = nullptr;
    for_each([&result] (const Type & item)
    {
      if (result == nullptr or item < *result)
        result = &item;
    });
    return result;
  }
 
  [[nodiscard]] const Type * max() const
    requires requires(Type a, Type b) { { a < b } -> std::convertible_to<bool>; }
  {
    const Type * result = nullptr;
    for_each([&result] (const Type & item)
    {
      if (result == nullptr or *result < item)
        result = &item;
    });
    return result;
  }
 
  template <class Compare>
    requires PredicateWith<Compare &, const Type &, const Type &>
  [[nodiscard]] const Type * min_by(Compare cmp) const
  {
    const Type * result = nullptr;
    for_each([&result, &cmp] (const Type & item)
    {
      if (result == nullptr or cmp(item, *result))
        result = &item;
    });
    return result;
  }
 
  template <class Compare>
    requires PredicateWith<Compare &, const Type &, const Type &>
  [[nodiscard]] const Type * max_by(Compare cmp) const
  {
    const Type * result = nullptr;
    for_each([&result, &cmp] (const Type & item)
    {
      if (result == nullptr or cmp(*result, item))
        result = &item;
    });
    return result;
  }
 
  // ---------------------------------------------------------------------------
  // Search and Counting
  // ---------------------------------------------------------------------------
 
  [[nodiscard]] bool has_value(const Type & val) const
    requires requires(Type a, Type b) { { a == b } -> std::convertible_to<bool>; }
  {
    return exists([&val] (const Type & item) { return item == val; });
  }
 
  template <class Predicate>
    requires PredicateWith<Predicate &, const Type &>
  [[nodiscard]] bool none(Predicate & pred) const
  {
    return not exists(pred);
  }
 
  template <class Predicate>
    requires PredicateWith<Predicate &, const Type &>
  [[nodiscard]] bool none(Predicate && pred) const
  {
    return not exists(std::forward<Predicate>(pred));
  }
 
  template <class Predicate>
    requires PredicateWith<Predicate &, const Type &>
  [[nodiscard]] size_t count_if(Predicate pred) const
  {
    size_t count = 0;
    for_each([&count, &pred] (const Type & item)
    {
      if (pred(item))
        ++count;
    });
    return count;
  }
 
  // ---------------------------------------------------------------------------
  // First/Last Element Access
  // ---------------------------------------------------------------------------
 
  [[nodiscard]] const Type * first() const
  {
    const Type * result = nullptr;
    self().traverse([&result] (const Type & item)
    {
      result = &item;
      return false;  // stop after first
    });
    return result;
  }
 
  [[nodiscard]] Type first_or(const Type & default_val) const
  {
    auto ptr = first();
    return ptr ? *ptr : default_val;
  }
 
  [[nodiscard]] const Type * last() const
  {
    const Type * result = nullptr;
    for_each([&result] (const Type & item)
    {
      result = &item;
    });
    return result;
  }
 
  [[nodiscard]] Type last_or(const Type & default_val) const
  {
    auto ptr = last();
    return ptr ? *ptr : default_val;
  }
 
  // ---------------------------------------------------------------------------
  // Enumeration and Indexing
  // ---------------------------------------------------------------------------
 
  template <template <typename> class Container = Aleph::DynList>
  [[nodiscard]] Container<std::pair<size_t, Type>> enumerate() const
  {
    Container<std::pair<size_t, Type>> ret;
    size_t idx = 0;
    for_each([&ret, &idx] (const Type & item)
    {
      ret.append(std::make_pair(idx++, item));
    });
    return ret;
  }
 
  template <class Predicate>
    requires PredicateWith<Predicate &, const Type &>
  [[nodiscard]] size_t find_index(Predicate pred) const
  {
    size_t idx = 0;
    size_t result = static_cast<size_t>(-1);
    self().traverse([&idx, &result, &pred] (const Type & item)
    {
      if (pred(item))
      {
        result = idx;
        return false;
      }
      ++idx;
      return true;
    });
    return result;
  }
 
  [[nodiscard]] size_t index_of(const Type & val) const
    requires requires(Type a, Type b) { { a == b } -> std::convertible_to<bool>; }
  {
    return find_index([&val] (const Type & item) { return item == val; });
  }
 
  // ---------------------------------------------------------------------------
  // Transformation (Advanced)
  // ---------------------------------------------------------------------------
 
  template <template <typename> class Container = Aleph::DynList>
  [[nodiscard]] Container<Type> unique() const
    requires requires(Type a, Type b) { { a == b } -> std::convertible_to<bool>; }
  {
    Container<Type> ret;
    const Type * prev = nullptr;
    for_each([&ret, &prev] (const Type & item)
    {
      if (prev == nullptr or not (*prev == item))
      {
        ret.append(item);
        prev = &item;
      }
    });
    return ret;
  }
 
  template <template <typename> class Container = Aleph::DynList, class EqPred>
    requires PredicateWith<EqPred &, const Type &, const Type &>
  [[nodiscard]] Container<Type> unique_by(EqPred eq) const
  {
    Container<Type> ret;
    const Type * prev = nullptr;
    for_each([&ret, &prev, &eq] (const Type & item)
    {
      if (prev == nullptr or not eq(*prev, item))
      {
        ret.append(item);
        prev = &item;
      }
    });
    return ret;
  }
 
  template <template <typename> class Container = Aleph::DynList>
  [[nodiscard]] Container<Type> intersperse(const Type & sep) const
  {
    Container<Type> ret;
    bool first = true;
    for_each([&ret, &sep, &first] (const Type & item)
    {
      if (not first)
        ret.append(sep);
      ret.append(item);
      first = false;
    });
    return ret;
  }
 
  // ---------------------------------------------------------------------------
  // Chunking and Windowing
  // ---------------------------------------------------------------------------
 
  template <template <typename> class Container = Aleph::DynList>
  [[nodiscard]] Container<Container<Type>> chunk(size_t n) const
  {
    Container<Container<Type>> ret;
    if (n == 0) return ret;
 
    Container<Type> current;
    size_t count = 0;
 
    for_each([&ret, &current, &count, n] (const Type & item)
    {
      current.append(item);
      if (++count >= n)
      {
        ret.append(std::move(current));
        current = Container<Type>{};
        count = 0;
      }
    });
 
    if (count > 0)
      ret.append(std::move(current));
 
    return ret;
  }
 
  template <template <typename> class Container = Aleph::DynList>
  [[nodiscard]] Container<Container<Type>> sliding(size_t size, size_t step = 1) const
  {
    Container<Container<Type>> ret;
    if (size == 0 or step == 0) return ret;
 
    // Collect all elements first
    Container<Type> all;
    for_each([&all] (const Type & item) { all.append(item); });
 
    size_t total = all.size();
    if (total < size) return ret;
 
    for (size_t start = 0; start + size <= total; start += step)
    {
      Container<Type> window;
      size_t idx = 0;
      all.traverse([&window, &idx, start, size] (const Type & item)
      {
        if (idx >= start and idx < start + size)
          window.append(item);
        ++idx;
        return idx < start + size;
      });
      ret.append(std::move(window));
    }
 
    return ret;
  }
 
  // ---------------------------------------------------------------------------
  // Conversion
  // ---------------------------------------------------------------------------
 
  [[nodiscard]] std::vector<Type> to_vector() const
  {
    std::vector<Type> ret;
    if constexpr (requires { self().size(); })
      ret.reserve(self().size());
    for_each([&ret] (const Type & item) { ret.push_back(item); });
    return ret;
  }
 
  template <typename DynListType = DynList<Type>>
  [[nodiscard]] DynListType to_dynlist() const
  {
    DynListType ret;
    for_each([&ret] (const Type & item) { ret.append(item); });
    return ret;
  }
 
  template <typename StringType = std::string>
  [[nodiscard]] StringType join(const StringType & sep = StringType{", "}) const
    requires requires(Type a) { std::to_string(a); }
  {
    StringType ret;
    bool first = true;
    for_each([&ret, &sep, &first] (const Type & item)
    {
      if (not first)
        ret += sep;
      ret += std::to_string(item);
      first = false;
    });
    return ret;
  }
 
  [[nodiscard]] std::string join_str(const std::string & sep = ", ") const
    requires std::is_convertible_v<Type, std::string>
  {
    std::string ret;
    bool first = true;
    for_each([&ret, &sep, &first] (const Type & item)
    {
      if (not first)
        ret += sep;
      ret += static_cast<std::string>(item);
      first = false;
    });
    return ret;
  }
 
  // ---------------------------------------------------------------------------
  // Zip Operations
  // ---------------------------------------------------------------------------
 
  template <class Other, template <typename> class Container = Aleph::DynList>
  [[nodiscard]] Container<std::pair<Type, typename Other::Item_Type>> 
  zip_with(const Other & other) const
  {
    using OtherType = typename Other::Item_Type;
    Container<std::pair<Type, OtherType>> ret;
 
    auto it1 = self().get_it();
    auto it2 = other.get_it();
 
    while (it1.has_curr() and it2.has_curr())
    {
      ret.append(std::make_pair(it1.get_curr(), it2.get_curr()));
      it1.next();
      it2.next();
    }
 
    return ret;
  }
};
 
 
// =============================================================================
// KeysMixin - Keys/Items extraction
// =============================================================================
 
template <typename Derived, typename Type>
class KeysMixin
{
protected:
  [[nodiscard]] const Derived& self() const noexcept
  {
    return static_cast<const Derived&>(*this);
  }
 
public:
  template <template <typename> class Container = DynList>
  [[nodiscard]] Container<Type> keys() const
  {
    return self().template maps<Type, Container>([] (const Type & key)
    {
      return key;
    });
  }
 
  template <template <typename> class Container = DynList>
  [[nodiscard]] Container<Type> items() const
  {
    return keys<Container>();
  }
};
 
 
} // end namespace Aleph
 
#endif // AH_DRY_MIXIN_H