typelist.h

#pragma once
 
#include "spark/mpl/type_seq.h"
 
namespace spark::mpl
{
    template <typename... Ts>
    struct typelist;
 
    // Base struct contains values and methods available in all typelists specializations
    template <typename... Ts>
    struct typelist_base
    {
        inline static constexpr std::size_t size = type_seq::size_v<Ts...>;
 
        inline static constexpr bool empty = type_seq::empty_v<Ts...>;
 
        template <typename T>
        inline static constexpr bool contains = type_seq::contains_v<T, Ts...>;
 
        template <typename T>
        using push_front = type_seq::push_front_t<T, typelist<Ts...>>;
 
        template <typename T>
        using push_back = type_seq::push_back_t<T, typelist<Ts...>>;
 
        using clear = typelist<>;
 
        template <template <typename...> typename T>
        using convert = type_seq::convert_t<T, Ts...>;
    };
 
    // Specialization for empty typelist
    template <>
    struct typelist<> : typelist_base<> {};
 
    // Specialization for typelist with at least one type
    template <typename First, typename... Ts>
    struct typelist<First, Ts...> : typelist_base<First, Ts...>
    {
        template <typename T>
        inline static constexpr std::size_t index_of = type_seq::index_of_v<T, First, Ts...>;
 
        template <typename T>
        inline static constexpr std::size_t find = type_seq::find_v<T, Ts...>;
 
        using front = type_seq::front_t<First, Ts...>;
 
        using back = type_seq::back_t<First, Ts...>;
 
        using pop_front = type_seq::pop_front_t<typelist<First, Ts...>>;
 
        using pop_back = type_seq::pop_back_t<typelist<First, Ts...>>;
 
        template <std::size_t N>
        using at = type_seq::at_t<N, typelist<First, Ts...>>;
 
        template <typename T>
        using erase = type_seq::erase_t<T, typelist<First, Ts...>>;
 
        template <std::size_t N>
        using erase_at = type_seq::erase_at_t<N, typelist<First, Ts...>>;
 
        template <std::size_t N, typename T>
        using insert_at = type_seq::insert_at_t<N, T, typelist<First, Ts...>>;
 
        template <typename T, typename U>
        using replace = type_seq::replace_t<T, U, typelist<First, Ts...>>;
 
        template <std::size_t N, typename T>
        using replace_at = type_seq::replace_at_t<N, T, typelist<First, Ts...>>;
 
        using reverse = type_seq::reverse_t<typelist<First, Ts...>>;
 
        template <template <typename> typename F>
        using filter = type_seq::filter_t<F, typelist<First, Ts...>>;
 
        template <template <typename...> typename T>
        using convert = type_seq::convert_t<T, First, Ts...>;
 
        template <template <typename> typename F>
        using transform = type_seq::transform_t<F, typelist<First, Ts...>>;
    };
 
    template <typename... Lists>
    using typelist_concat = type_seq::concat_t<Lists...>;
 
    template <typename List>
    using typelist_flatten = type_seq::flatten_t<List>;
 
    template <template <typename, typename> typename Matcher, typename L1, typename L2>
    static constexpr bool typelist_match = type_seq::match_v<Matcher, L1, L2>;
}