A simple way to join two arrays constexpr

constexpr_join_array.cpp

namespace detail
{
template<std::size_t ... Size>
struct num_tuple
{

};

template<std::size_t Prepend, typename T>
struct appender {};

template<std::size_t Prepend, std::size_t ... Sizes>
struct appender<Prepend, num_tuple<Sizes...>>
{
	using type = num_tuple<Prepend, Sizes...>;
};

template<std::size_t Size, std::size_t Counter = 0>
struct counter_tuple
{
	using type = typename appender<Counter, typename counter_tuple<Size, Counter+1>::type>::type;
};


template<std::size_t Size>
struct counter_tuple<Size, Size>
{
	using type = num_tuple<>;
};

}


template<typename T, std::size_t LL, std::size_t RL, std::size_t ... LLs, std::size_t ... RLs>
constexpr std::array<T, LL+RL> join(const std::array<T, LL> rhs, const std::array<T, RL> lhs, detail::num_tuple<LLs...>, detail::num_tuple<RLs...>)
{
	return {rhs[LLs]..., lhs[RLs]... };
};


template<typename T, std::size_t LL, std::size_t RL>
constexpr std::array<T, LL+RL> join(std::array<T, LL> rhs, std::array<T, RL> lhs)
{
	//using l_t = typename detail::counter_tuple<LL>::type;
	return join(rhs, lhs, typename detail::counter_tuple<LL>::type(), typename detail::counter_tuple<RL>::type());
}

int main()
{
	using namespace std;
	constexpr std::array<int, 3> l = {1,2,3};
	constexpr std::array<int, 3> r = {4,5,6};

	constexpr auto s = join(l,r);

	return 0;
}

In c++20, this can be made simpler :

template<typename T, std::size_t LL, std::size_t RL>
constexpr std::array<T, LL+RL> join(std::array<T, LL> rhs, std::array<T, RL> lhs)
{
std::array<T, LL+RL> ar;

auto current = std::copy(rhs.begin(), rhs.end(), ar.begin());
std::copy(lhs.begin(), lhs.end(), current);

return ar;
}