C++ typelist make sublist - c++

Question

Let's says I have a type
template<typename ...Ts>
struct typelist {};
I need to get a sublist from this list :
template<int startInclusive, int stopExclusive, typename ...Ts>
struct sublist {
using type = ?; //
};
for example
sublist<1, 3, int, float, double, char>::type == typelist<float, double>
When start = 0 I have a working tail implementation :
template<typename ...Ts>
struct typelist {};
template<int N, typename T, typename ...Ts>
struct tail {
using type = typename tail<N - 1, Ts...>::type;
};
template<typename T, typename ...Ts>
struct tail<0, T, Ts...> {
using type = typelist<T, Ts...>;
};
using T = tail<1, int, double>::type;
#include <typeinfo>
#include <cstdio>
int main() {
::printf("%s\n", typeid(T).name());
}
However, I cannot get anything working for start > 0

Answer 1

As usual, std::index_sequence helps here:
template <std::size_t Offset, typename Seq, typename Tuple> struct sublist_impl;
template <std::size_t Offset, std::size_t ... Is, typename Tuple>
struct sublist_impl<Offset, std::index_sequence<Is...>, Tuple>
{
using type = std::tuple<std::tuple_element_t<Offset + Is, Tuple>...>;
};
template<std::size_t startInclusive, std::size_t stopExclusive, typename ...Ts>
using sublist = typename sublist_impl<startInclusive,
std::make_index_sequence<stopExclusive - startInclusive>,
std::tuple<Ts...>>::type;
Demo

Answer 2

It's likely to be an overkill, but it works:
template<typename... Ts>
struct typelist {};
template<class Typelist, typename T>
struct prepend;
template<typename... Ts, typename T>
struct prepend<typelist<Ts...>, T> {
using type = typelist<T, Ts...>;
};
template<int start, int stop, int i, typename... Ts>
struct sublist_impl {
using type = typelist<>;
};
template<int start, int stop, int i, typename T, typename... Ts>
struct sublist_impl<start, stop, i, T, Ts...>
{
private:
static constexpr auto get_sublist_type() {
if constexpr (i < start)
return typename sublist_impl<start, stop, i + 1, Ts...>::type{};
else if constexpr (i < stop)
return typename prepend<typename sublist_impl<
start, stop, i + 1, Ts...>::type, T>::type{};
else
return typelist<>{};
}
public:
using type = decltype(get_sublist_type());
};
template<int start, int stop, typename... Ts>
struct sublist {
using type = typename sublist_impl<start, stop, 0, Ts...>::type;
};
template<int start, int stop, typename... Ts>
using sublist_t = typename sublist<start, stop, Ts...>::type;
static_assert(std::is_same_v<
sublist_t<1, 3, int, float, double, char>, typelist<float, double>>);
static_assert(std::is_same_v<
sublist_t<0, 0, int, float, double, char>, typelist<>>);
static_assert(std::is_same_v<
sublist_t<4, 4, int, float, double, char>, typelist<>>);
static_assert(std::is_same_v<
sublist_t<0, 3, int, float, double, char>, typelist<int, float, double>>);
static_assert(std::is_same_v<
sublist_t<0, 4, int, float, double, char>, typelist<int, float, double, char>>);

Answer 3

Just for fun, the std::tuple_cat() way
#include <tuple>
#include <type_traits>
template<typename ...Ts>
struct typelist
{ };
template <std::size_t sI, std::size_t sE, std::size_t I, typename T>
constexpr std::enable_if_t<(I >= sI) && (I < sE),
std::tuple<typelist<T>>> getTpl ();
template <std::size_t sI, std::size_t sE, std::size_t I, typename T>
constexpr std::enable_if_t<(I < sI) || (I >= sE),
std::tuple<>> getTpl ();
template <typename ... Ts>
constexpr typelist<Ts...> getList (std::tuple<typelist<Ts>...>);
template <std::size_t sI, std::size_t sE, typename ... Ts,
std::size_t ... Is>
constexpr auto getTplList (typelist<Ts...>, std::index_sequence<Is...>)
-> decltype( getList(std::tuple_cat(getTpl<sI, sE, Is, Ts>()...)) );
template <std::size_t startI, std::size_t stopE, typename ... Ts>
struct sublist
{
using type = decltype(getTplList<startI, stopE>
(typelist<Ts...>{},
std::index_sequence_for<Ts...>{}));
};
int main ()
{
using type1 = typename sublist<1u, 3u, int, float, double, char>::type;
using type2 = typelist<float, double>;
static_assert( std::is_same<type1, type2>::value, "!" );
}