From 8d42ed7eec07d41c53d10de7fa7e3bef2d063a70 Mon Sep 17 00:00:00 2001
From: Mateusz Pusz <mateusz.pusz@gmail.com>
Date: Fri, 28 Sep 2018 14:20:23 -0700
Subject: [PATCH] Type List interface made generic

---
 src/include/units/bits/type_list.h | 112 ++++++++++++++---------------
 test/test_type_list.cpp            |  11 +--
 2 files changed, 62 insertions(+), 61 deletions(-)

diff --git a/src/include/units/bits/type_list.h b/src/include/units/bits/type_list.h
index da2bc7da..ba2257de 100644
--- a/src/include/units/bits/type_list.h
+++ b/src/include/units/bits/type_list.h
@@ -27,32 +27,30 @@
 
 namespace mp {
 
-  // type_list
+//  namespace detail {
+//
+//    template<typename T>
+//    struct is_type_list : std::false_type {};
+//
+//    template<template<typename...> typename T, typename... Types>
+//    struct is_type_list<T<Types...>> : std::true_type {};
+//
+//  }
 
-  template<typename... Types>
-  struct type_list;
-
-  namespace detail {
-
-    template<typename T>
-    struct is_type_list : std::false_type {};
-
-    template<typename... Types>
-    struct is_type_list<type_list<Types...>> : std::true_type {};
-
-  }
-
-  template<typename T>
-  bool concept TypeList = detail::is_type_list<T>::value;
+//  template<template<typename...> typename T, typename... Types>
+//  concept bool TypeList = requires(T<Types...>) {
+//    std::is_empty_v<T<Types...>>;
+//  };
+#define TypeList typename
 
   // push_front
 
   template<TypeList List, typename... Types>
   struct type_list_push_front;
 
-  template<typename... OldTypes, typename... NewTypes>
-  struct type_list_push_front<type_list<OldTypes...>, NewTypes...> {
-    using type = type_list<NewTypes..., OldTypes...>;
+  template<template<typename...> typename List, typename... OldTypes, typename... NewTypes>
+  struct type_list_push_front<List<OldTypes...>, NewTypes...> {
+    using type = List<NewTypes..., OldTypes...>;
   };
 
   template<TypeList List, typename... Types>
@@ -63,9 +61,9 @@ namespace mp {
   template<TypeList List, typename... Types>
   struct type_list_push_back;
 
-  template<typename... OldTypes, typename... NewTypes>
-  struct type_list_push_back<type_list<OldTypes...>, NewTypes...> {
-    using type = type_list<OldTypes..., NewTypes...>;
+  template<template<typename...> typename List, typename... OldTypes, typename... NewTypes>
+  struct type_list_push_back<List<OldTypes...>, NewTypes...> {
+    using type = List<OldTypes..., NewTypes...>;
   };
 
   template<TypeList List, typename... Types>
@@ -75,18 +73,18 @@ namespace mp {
 
   namespace detail {
 
-    template<std::size_t Idx, std::size_t N, typename... Types>
+    template<template<typename...> typename List, std::size_t Idx, std::size_t N, typename... Types>
     struct split_impl;
 
-    template<std::size_t Idx, std::size_t N>
-    struct split_impl<Idx, N> {
-      using first_list = type_list<>;
-      using second_list = type_list<>;
+    template<template<typename...> typename List, std::size_t Idx, std::size_t N>
+    struct split_impl<List, Idx, N> {
+      using first_list = List<>;
+      using second_list = List<>;
     };
 
-    template<std::size_t Idx, std::size_t N, typename T, typename... Rest>
-    struct split_impl<Idx, N, T, Rest...> : split_impl<Idx + 1, N, Rest...> {
-      using base = split_impl<Idx + 1, N, Rest...>;
+    template<template<typename...> typename List, std::size_t Idx, std::size_t N, typename T, typename... Rest>
+    struct split_impl<List, Idx, N, T, Rest...> : split_impl<List, Idx + 1, N, Rest...> {
+      using base = split_impl<List, Idx + 1, N, Rest...>;
       using base_first = typename base::first_list;
       using base_second = typename base::second_list;
       using first_list = std::conditional_t<Idx<N, type_list_push_front_t<base_first, T>, base_first>;
@@ -98,10 +96,10 @@ namespace mp {
   template<TypeList List, std::size_t N>
   struct type_list_split;
 
-  template<std::size_t N, typename... Types>
-  struct type_list_split<type_list<Types...>, N> {
+  template<template<typename...> typename List, std::size_t N, typename... Types>
+  struct type_list_split<List<Types...>, N> {
     static_assert(N <= sizeof...(Types), "Invalid index provided");
-    using split = detail::split_impl<0, N, Types...>;
+    using split = detail::split_impl<List, 0, N, Types...>;
     using first_list = typename split::first_list;
     using second_list = typename split::second_list;
   };
@@ -111,8 +109,8 @@ namespace mp {
   template<TypeList List>
   struct type_list_split_half;
 
-  template<typename... Types>
-  struct type_list_split_half<type_list<Types...>> : type_list_split<type_list<Types...>, (sizeof...(Types) + 1) / 2> {
+  template<template<typename...> typename List, typename... Types>
+  struct type_list_split_half<List<Types...>> : type_list_split<List<Types...>, (sizeof...(Types) + 1) / 2> {
   };
 
   // merge_sorted
@@ -123,24 +121,24 @@ namespace mp {
   template<TypeList SortedList1, TypeList SortedList2, template<typename, typename> typename Pred>
   using type_list_merge_sorted_t = typename type_list_merge_sorted<SortedList1, SortedList2, Pred>::type;
 
-  template<typename... Lhs, template<typename, typename> typename Pred>
-  struct type_list_merge_sorted<type_list<Lhs...>, type_list<>, Pred> {
-    using type = type_list<Lhs...>;
+  template<template<typename...> typename List, typename... Lhs, template<typename, typename> typename Pred>
+  struct type_list_merge_sorted<List<Lhs...>, List<>, Pred> {
+    using type = List<Lhs...>;
   };
 
-  template<typename... Rhs, template<typename, typename> typename Pred>
-  struct type_list_merge_sorted<type_list<>, type_list<Rhs...>, Pred> {
-    using type = type_list<Rhs...>;
+  template<template<typename...> typename List, typename... Rhs, template<typename, typename> typename Pred>
+  struct type_list_merge_sorted<List<>, List<Rhs...>, Pred> {
+    using type = List<Rhs...>;
   };
 
-  template<typename Lhs1, typename... LhsRest, typename Rhs1, typename... RhsRest,
+  template<template<typename...> typename List, typename Lhs1, typename... LhsRest, typename Rhs1, typename... RhsRest,
            template<typename, typename> typename Pred>
-  struct type_list_merge_sorted<type_list<Lhs1, LhsRest...>, type_list<Rhs1, RhsRest...>, Pred> {
+  struct type_list_merge_sorted<List<Lhs1, LhsRest...>, List<Rhs1, RhsRest...>, Pred> {
     using type = std::conditional_t<
         Pred<Lhs1, Rhs1>::value,
-        type_list_push_front_t<type_list_merge_sorted_t<type_list<LhsRest...>, type_list<Rhs1, RhsRest...>, Pred>,
+        type_list_push_front_t<type_list_merge_sorted_t<List<LhsRest...>, List<Rhs1, RhsRest...>, Pred>,
                                Lhs1>,
-        type_list_push_front_t<type_list_merge_sorted_t<type_list<Lhs1, LhsRest...>, type_list<RhsRest...>, Pred>,
+        type_list_push_front_t<type_list_merge_sorted_t<List<Lhs1, LhsRest...>, List<RhsRest...>, Pred>,
                                Rhs1>>;
   };
 
@@ -149,26 +147,26 @@ namespace mp {
   template<TypeList List, template<typename, typename> typename Pred>
   struct type_list_sort;
 
-  template<template<typename, typename> typename Pred>
-  struct type_list_sort<type_list<>, Pred> {
-    using type = type_list<>;
+  template<template<typename...> typename List, template<typename, typename> typename Pred>
+  struct type_list_sort<List<>, Pred> {
+    using type = List<>;
   };
 
-  template<typename T, template<typename, typename> typename Pred>
-  struct type_list_sort<type_list<T>, Pred> {
-    using type = type_list<T>;
+  template<template<typename...> typename List, typename T, template<typename, typename> typename Pred>
+  struct type_list_sort<List<T>, Pred> {
+    using type = List<T>;
   };
 
-  template<typename... Types, template<typename, typename> typename Pred>
-  struct type_list_sort<type_list<Types...>, Pred> {
-    using types = type_list<Types...>;
-    using split = type_list_split_half<type_list<Types...>>;
+  template<template<typename...> typename List, typename... Types, template<typename, typename> typename Pred>
+  struct type_list_sort<List<Types...>, Pred> {
+    using types = List<Types...>;
+    using split = type_list_split_half<List<Types...>>;
     using left = typename type_list_sort<typename split::first_list, Pred>::type;
     using right = typename type_list_sort<typename split::second_list, Pred>::type;
     using type = type_list_merge_sorted_t<left, right, Pred>;
   };
 
-  template<TypeList TypeList, template<typename, typename> typename Pred>
-  using type_list_sort_t = typename type_list_sort<TypeList, Pred>::type;
+  template<TypeList List, template<typename, typename> typename Pred>
+  using type_list_sort_t = typename type_list_sort<List, Pred>::type;
 
 }  // namespace mp
\ No newline at end of file
diff --git a/test/test_type_list.cpp b/test/test_type_list.cpp
index cb14cbc4..abdaf9ed 100644
--- a/test/test_type_list.cpp
+++ b/test/test_type_list.cpp
@@ -28,6 +28,9 @@ namespace {
   using namespace mp;
   using namespace units;
 
+  template<typename... Types>
+  struct type_list;
+
   // type_list_push_front
 
   static_assert(std::is_same_v<type_list_push_front_t<type_list<>, int>, type_list<int>>);
@@ -95,8 +98,8 @@ namespace {
 
   // type_list_sort
 
-  template<typename TypeList>
-  using dim_sort_t = type_list_sort_t<TypeList, dim_id_less>;
+  template<TypeList List>
+  using dim_sort_t = type_list_sort_t<List, dim_id_less>;
 
   static_assert(std::is_same_v<dim_sort_t<type_list<dim_id<0>>>, type_list<dim_id<0>>>);
   static_assert(std::is_same_v<dim_sort_t<type_list<dim_id<0>, dim_id<1>>>, type_list<dim_id<0>, dim_id<1>>>);
@@ -110,8 +113,8 @@ namespace {
   template<int Id, int Value>
   using e = exp<dim_id<Id>, Value>;
 
-  template<typename TypeList>
-  using exp_sort_t = type_list_sort_t<TypeList, exp_less>;
+  template<TypeList List>
+  using exp_sort_t = type_list_sort_t<List, exp_less>;
 
   static_assert(std::is_same_v<exp_sort_t<dimension<e<0, 1>>>, dimension<e<0, 1>>>);
   static_assert(std::is_same_v<exp_sort_t<dimension<e<0, 1>, e<1, -1>>>, dimension<e<0, 1>, e<1, -1>>>);