enumerate multidimensional grid points at compile time

#include <type_traits>
#include <utility>

template< typename validator, std::size_t ...indices >
struct enumerator;

template< typename validator >
struct enumerator< validator >
{

    constexpr
    enumerator(validator && _validator)
        : validator_(std::forward< validator >(_validator))
    { ; }

    template< std::size_t ...I >
    constexpr
    bool
    operator () () const
    {
        return validator_(std::index_sequence< I... >{});
    }

private :

    validator validator_;

};

template< typename validator, std::size_t first, std::size_t ...rest >
struct enumerator< validator, first, rest... >
    : enumerator< validator, rest... >
{

    constexpr
    enumerator(validator && _validator)
        : enumerator< validator, rest... >(std::forward< validator >(_validator))
    { ; }

    template< std::size_t ...I >
    constexpr
    bool
    operator () () const
    {
        return enumerator::template operator () < I... >(std::make_index_sequence< first >{}); // ltr
    }

    template< std::size_t ...I, std::size_t ...J >
    constexpr
    bool
    operator () (std::index_sequence< J... >) const
    {
        return (enumerator< validator, rest... >::template operator () < I..., J >() && ...); // rtl, `< J, I... >` - ltr
    }

};

template< std::size_t ...I, typename validator >
constexpr
enumerator< validator, I... >
make_enumerator(validator && _validator)
{
    static_assert(0 < sizeof...(I));
    static_assert(((0 < I) && ...));
    return std::forward< validator >(_validator);
}

// main.cpp

#include <iostream>

#include <cstdlib>
#include <cassert>

struct truth
{

    template< std::size_t ...I >
    constexpr
    bool
    operator () (std::index_sequence< I... >) const
    {
        return true;
    }

};

struct printer
{

    template< std::size_t ...I >
    bool
    operator () (std::index_sequence< I... >) const
    {
        for (std::size_t const & i : {I...}) {
            std::cout << i << ' ';
        }
        std::cout << std::endl;
        return true;
    }

};

int
main()
{
    static_assert(make_enumerator< 10, 10, 10, 10, 2 >(truth{})());
    assert((make_enumerator< 10, 10 >(printer{})()));
    return EXIT_SUCCESS;
}