enumarete_adl.hpp

// https://godbolt.org/z/pujcf7

#include <utility>
#include <tuple>

namespace rz
{
namespace adl
{
using std::begin;
using std::end;
template <class T> auto adlbegin(T &&t)
{
    return begin(std::forward<T>(t));
}
template <class T> auto adlend(T &&t)
{
    return end(std::forward<T>(t));
}
} // namespace adl

namespace details
{
template <class T> std::add_lvalue_reference_t<T> declval();
} // namespace details

template <class T,
          class TI = decltype(adl::adlbegin(details::declval<T>()))
         >
constexpr auto enumerate(T &&t)
{
    struct iterator
    {
        size_t i;
        TI iter;
        bool operator != (const iterator &other) const
        {
            return iter != other.iter;
        }
        iterator& operator++ ()
        {
            ++this->i;
            ++this->iter;
            return *this;
        }
        auto operator* () const
        {
            return std::tie(this->i, *this->iter);
        }
    };
    
    struct wrapper
    {
        T iterable;
        auto begin()
        {
            return iterator{0, adl::adlbegin(iterable)};
        }
        auto end()
        {
            return iterator{0, adl::adlend(iterable)};
        }
    };
    return wrapper{ std::forward<T>(t) };
}
}