C++1z - Throwing compile error if condition occurs during template unfolding - c++

Question

I'm writing a template that defines a type that is given to it in type parameter pack, and whose position is the same as number passed to the template. Here's what I've written:
template<size_t I, typename T, typename... Ts>
struct get_type {
typedef typename std::conditional<I == 0, T, typename get_type<I-1, Ts...>::type>::type type;
};
template<size_t I, typename T>
struct get_type<I, T> {
// This works only if compiler stops unfolding the template when I == 0
static_assert(I == 0, "get_type - index out of bounds");
typedef T type;
};
Problem with this approach, if we write code like this:
static_assert(std::is_same<double, get_type<1,int,double,float>::type>::value, "I wanted double!");
Compiler still "unfolds" the template to the end (even though it should know the type till then, exactly when I is equal to 0), and at the end I overflows and is no longer equal to 0, which means static_assert throws error, that index I is out of bounds. But I still want to somehow throw an error during compile time, if I is TRULLY out of bounds. Is there any way to do that?

Answer 1

The compiler has to unfold the template otherwise it wouldn't know what the type of type is.
std::tuple_element_t already gives a (rather verbose) error if the index is out of bounds.
template<size_t I, typename... Ts>
using get_type_t = std::tuple_element_t<I, std::tuple<Ts...>>;
A more intuitive error message can be made by using this in concert with an explicit bounds check:
template<size_t I, typename... Ts>
struct get_type {
using L=std::tuple<Ts...>;
static_assert(I < 0 || I >= std::tuple_size<L>(), "out of bounds");
using type = std::tuple_element_t<I, L>;
};
template<size_t I, typename... Ts>
using get_type_t = typename get_type<I, Ts...>::type;
Here's an example without the overhead of std::tuple (adapted from boostcon):
struct empty{};
template<class T>
struct tag_t:empty{};
template<class T>
tag_t<T> tag{};
template <typename ignore>
struct lookup;
template <std::size_t... ignore>
struct lookup<std::index_sequence<ignore...>> {
template <typename nth>
static nth
apply(decltype(ignore, empty())..., tag_t<nth>, ...);
};
template<std::size_t I, class... Ts>
using get_type = decltype(
lookup<std::make_index_sequence<I>>::apply(tag<Ts>...)
);
// Test
static_assert(std::is_same<get_type<1, int, float, int>, float>(), "");
static_assert(std::is_same<get_type<0, int, float, int>, int>(), "");

Answer 2

Here's an answer I came up with:
struct error_type {};
template<size_t I, typename T, typename... Ts>
struct get_type {
typedef typename std::conditional<I == 0, T, typename get_type<I-1, Ts...>::type>::type type;
static_assert(!std::is_same<type, error_type>::value, "get_type - index out of bounds");
};
template<size_t I, typename T>
struct get_type<I, T> {
typedef typename std::conditional<I == 0, T, error_type>::type type;
};
But it seems a little verbose (we're creating a dummy structure), so I'm leaving this question in case someone comes up with something smarter then my solution...