1 files changed, 78 insertions, 46 deletions
diff --git a/compat/meta.hpp b/compat/meta.hpp
index 80eca89a..49686996 100644
--- a/compat/meta.hpp
+++ b/compat/meta.hpp
@@ -7,26 +7,12 @@
  * copyright notice and this permission notice appear in all copies.
  */
 
-#include <type_traits>
+namespace meta::detail {
 
-template<typename t>
-using cv_qualified = std::conditional_t<std::is_fundamental_v<std::decay_t<t>>, std::decay_t<t>, const t&>;
+    template<typename... xs>
+    struct tuple;
 
-#define progn(...) (([&]() { __VA_ARGS__ })())
-#define prog1(x, ...) (([&]() { auto _ret1324 = (x); do { __VA_ARGS__; } while (0); return _ret1324; })())
-
-#define once_only(...) do { static bool once__ = false; if (!once__) { once__ = true; __VA_ARGS__; } } while(false)
-
-#if 0
-
-#include <tuple>
-#include <cstddef>
-
-namespace meta {
-
-namespace detail {
-
-    template<typename x, typename y>
+    template<typename... xs>
     struct reverse_;
 
     template<typename x0, typename... xs, template<typename...> class x, typename... ys>
@@ -41,51 +27,97 @@ namespace detail {
         using type = x<ys...>;
     };
 
-    template<template<typename...> class inst, typename x>
-    struct lift_;
+    template<template<typename...> class, typename, typename...> struct lift_;
 
-    template<template<typename...> class inst, template<typename...> class x, typename... xs>
-    struct lift_<inst, x<xs...>>
+    template<template<typename...> class to, template<typename...> class from, typename... xs>
+    struct lift_<to, from<xs...>>
     {
-        using type = inst<xs...>;
+        using type = to<xs...>;
     };
 
-    template<typename N, N max, N pos, typename... xs>
-    struct index_sequence_
+    template<typename> struct append_helper;
+
+    template<typename, typename> struct cons_;
+
+    template<typename x, template<typename...> class t, typename... xs>
+    struct cons_<x, t<xs...>>
     {
-        using part = std::integral_constant<N, pos>;
-        using type = typename index_sequence_<N, max, pos+1, xs..., part>::type;
+        using type = t<x, xs...>;
     };
 
-    template<typename N, N max, typename... xs>
-    struct index_sequence_<N, max, max, xs...>
+    template<typename> struct append2;
+
+    template<template<typename...> class t, typename... xs>
+    struct append2<t<xs...>>
     {
-        using type = std::tuple<xs...>;
+        template<typename> struct append1;
+
+        template<template<typename...> class u, typename... ys>
+        struct append1<u<ys...>>
+        {
+            using type = t<xs..., ys...>;
+        };
     };
-} // ns detail
 
+    template<typename, typename...> struct list__;
+
+    template<typename rest, typename... first>
+    struct list__
+    {
+        template<typename> struct list1;
+
+        template<template<typename...> class t, typename... xs>
+        struct list1<t<xs...>>
+        {
+            using type = t<first..., xs...>;
+        };
+
+        using type = typename list1<rest>::type;
+    };
+
+    template<typename xs, typename ys>
+    struct append_
+    {
+        using t1 = append2<xs>;
+        using type = typename t1::template append1<ys>::type;
+    };
+
+} // ns meta::detail
+
+namespace meta {
+    template<typename... xs>
+    using tuple_ = detail::tuple<xs...>;
+
+    template<typename... xs>
+    using reverse = typename detail::reverse_<detail::tuple<xs...>, detail::tuple<>>::type;
+
+    // the to/from order is awkward but mimics function composition
+    template<template<typename...> class to, typename from>
+    using lift = typename detail::lift_<to, from>::type;
+
+    template<template<typename...> class to, typename from>
+    constexpr inline auto lift_v = detail::lift_<to, from>::type::value;
 
-template<typename... xs>
-using reverse = typename detail::reverse_<std::tuple<xs...>, std::tuple<>>::type;
+    template<typename x, typename... xs>
+    using first = x;
 
-template<template<typename...> class inst, class x>
-using lift = typename detail::lift_<inst, x>::type;
+    template<typename x, typename... xs>
+    using rest = detail::tuple<xs...>;
 
-template<typename x, typename... xs>
-using first = x;
+    template<typename... xs>
+    using butlast = reverse<rest<reverse<xs...>>>;
 
-template<typename x, typename... xs>
-using rest = std::tuple<xs...>;
+    template<typename... xs>
+    using last = lift<first, reverse<xs...>>;
 
-template<typename... xs>
-using butlast = reverse<rest<reverse<xs...>>>;
+    template<typename x, typename rest>
+    using cons = typename detail::cons_<x, rest>::type;
 
-template<typename... xs>
-using last = lift<first, reverse<xs...>>;
+    template<typename xs, typename ys>
+    using append = typename detail::append_<xs, ys>;
 
-template<std::size_t max>
-using index_sequence = typename detail::index_sequence_<std::size_t, max, std::size_t(0)>::type;
+    template<typename rest, typename... xs>
+    using list_ = typename detail::list__<rest, xs...>;
 
 } // ns meta
 
-#endif